rclone_sdk/lib.rs
1#[allow(unused_imports)]
2use progenitor_client::{encode_path, ClientHooks, OperationInfo, RequestBuilderExt};
3#[allow(unused_imports)]
4pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
5/// Types used as operation parameters and responses.
6#[allow(clippy::all)]
7pub mod types {
8 /// Error types.
9 pub mod error {
10 /// Error from a `TryFrom` or `FromStr` implementation.
11 pub struct ConversionError(::std::borrow::Cow<'static, str>);
12 impl ::std::error::Error for ConversionError {}
13 impl ::std::fmt::Display for ConversionError {
14 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
15 ::std::fmt::Display::fmt(&self.0, f)
16 }
17 }
18
19 impl ::std::fmt::Debug for ConversionError {
20 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
21 ::std::fmt::Debug::fmt(&self.0, f)
22 }
23 }
24
25 impl From<&'static str> for ConversionError {
26 fn from(value: &'static str) -> Self {
27 Self(value.into())
28 }
29 }
30
31 impl From<String> for ConversionError {
32 fn from(value: String) -> Self {
33 Self(value.into())
34 }
35 }
36 }
37
38 ///`BackendCommandRequest`
39 ///
40 /// <details><summary>JSON schema</summary>
41 ///
42 /// ```json
43 ///{
44 /// "type": "object",
45 /// "properties": {
46 /// "_async": {
47 /// "description": "Run the command asynchronously. Returns a job id
48 /// immediately.",
49 /// "type": "boolean"
50 /// },
51 /// "_group": {
52 /// "description": "Assign the request to a custom stats group.",
53 /// "type": "string"
54 /// },
55 /// "arg": {
56 /// "description": "Optional positional arguments for the backend
57 /// command.",
58 /// "type": "array",
59 /// "items": {
60 /// "type": "string"
61 /// }
62 /// },
63 /// "command": {
64 /// "description": "Backend-specific command to invoke.",
65 /// "type": "string"
66 /// },
67 /// "fs": {
68 /// "description": "Remote name or path the backend command should
69 /// target.",
70 /// "type": "string"
71 /// },
72 /// "opt": {
73 /// "description": "Backend command options encoded as a JSON string.",
74 /// "type": "string"
75 /// }
76 /// }
77 ///}
78 /// ```
79 /// </details>
80 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
81 pub struct BackendCommandRequest {
82 ///Optional positional arguments for the backend command.
83 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
84 pub arg: ::std::vec::Vec<::std::string::String>,
85 ///Run the command asynchronously. Returns a job id immediately.
86 #[serde(
87 rename = "_async",
88 default,
89 skip_serializing_if = "::std::option::Option::is_none"
90 )]
91 pub async_: ::std::option::Option<bool>,
92 ///Backend-specific command to invoke.
93 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
94 pub command: ::std::option::Option<::std::string::String>,
95 ///Remote name or path the backend command should target.
96 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
97 pub fs: ::std::option::Option<::std::string::String>,
98 ///Assign the request to a custom stats group.
99 #[serde(
100 rename = "_group",
101 default,
102 skip_serializing_if = "::std::option::Option::is_none"
103 )]
104 pub group: ::std::option::Option<::std::string::String>,
105 ///Backend command options encoded as a JSON string.
106 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
107 pub opt: ::std::option::Option<::std::string::String>,
108 }
109
110 impl ::std::convert::From<&BackendCommandRequest> for BackendCommandRequest {
111 fn from(value: &BackendCommandRequest) -> Self {
112 value.clone()
113 }
114 }
115
116 impl ::std::default::Default for BackendCommandRequest {
117 fn default() -> Self {
118 Self {
119 arg: Default::default(),
120 async_: Default::default(),
121 command: Default::default(),
122 fs: Default::default(),
123 group: Default::default(),
124 opt: Default::default(),
125 }
126 }
127 }
128
129 ///`BackendCommandResponse`
130 ///
131 /// <details><summary>JSON schema</summary>
132 ///
133 /// ```json
134 ///{
135 /// "type": "object",
136 /// "properties": {
137 /// "result": {
138 /// "description": "Backend command result payload"
139 /// }
140 /// },
141 /// "additionalProperties": true
142 ///}
143 /// ```
144 /// </details>
145 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
146 pub struct BackendCommandResponse {
147 ///Backend command result payload
148 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
149 pub result: ::std::option::Option<::serde_json::Value>,
150 }
151
152 impl ::std::convert::From<&BackendCommandResponse> for BackendCommandResponse {
153 fn from(value: &BackendCommandResponse) -> Self {
154 value.clone()
155 }
156 }
157
158 impl ::std::default::Default for BackendCommandResponse {
159 fn default() -> Self {
160 Self {
161 result: Default::default(),
162 }
163 }
164 }
165
166 ///`CacheExpireRequest`
167 ///
168 /// <details><summary>JSON schema</summary>
169 ///
170 /// ```json
171 ///{
172 /// "type": "object",
173 /// "properties": {
174 /// "_async": {
175 /// "description": "Run the command asynchronously. Returns a job id
176 /// immediately.",
177 /// "type": "boolean"
178 /// },
179 /// "_group": {
180 /// "description": "Assign the request to a custom stats group.",
181 /// "type": "string"
182 /// },
183 /// "remote": {
184 /// "description": "Remote path to expire from the cache, e.g.
185 /// `remote:path/to/dir`.",
186 /// "type": "string"
187 /// },
188 /// "withData": {
189 /// "description": "Set to true to drop cached chunk data along with
190 /// directory entries.",
191 /// "type": "boolean"
192 /// }
193 /// }
194 ///}
195 /// ```
196 /// </details>
197 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
198 pub struct CacheExpireRequest {
199 ///Run the command asynchronously. Returns a job id immediately.
200 #[serde(
201 rename = "_async",
202 default,
203 skip_serializing_if = "::std::option::Option::is_none"
204 )]
205 pub async_: ::std::option::Option<bool>,
206 ///Assign the request to a custom stats group.
207 #[serde(
208 rename = "_group",
209 default,
210 skip_serializing_if = "::std::option::Option::is_none"
211 )]
212 pub group: ::std::option::Option<::std::string::String>,
213 ///Remote path to expire from the cache, e.g. `remote:path/to/dir`.
214 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
215 pub remote: ::std::option::Option<::std::string::String>,
216 ///Set to true to drop cached chunk data along with directory entries.
217 #[serde(
218 rename = "withData",
219 default,
220 skip_serializing_if = "::std::option::Option::is_none"
221 )]
222 pub with_data: ::std::option::Option<bool>,
223 }
224
225 impl ::std::convert::From<&CacheExpireRequest> for CacheExpireRequest {
226 fn from(value: &CacheExpireRequest) -> Self {
227 value.clone()
228 }
229 }
230
231 impl ::std::default::Default for CacheExpireRequest {
232 fn default() -> Self {
233 Self {
234 async_: Default::default(),
235 group: Default::default(),
236 remote: Default::default(),
237 with_data: Default::default(),
238 }
239 }
240 }
241
242 ///`CacheFetchRequest`
243 ///
244 /// <details><summary>JSON schema</summary>
245 ///
246 /// ```json
247 ///{
248 /// "type": "object",
249 /// "properties": {
250 /// "_async": {
251 /// "description": "Run the command asynchronously. Returns a job id
252 /// immediately.",
253 /// "type": "boolean"
254 /// },
255 /// "_group": {
256 /// "description": "Assign the request to a custom stats group.",
257 /// "type": "string"
258 /// },
259 /// "chunks": {
260 /// "description": "Comma-separated chunk specifier list (e.g.
261 /// `0:10,25:30`) describing file pieces to prefetch.",
262 /// "type": "string"
263 /// }
264 /// },
265 /// "additionalProperties": true
266 ///}
267 /// ```
268 /// </details>
269 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
270 pub struct CacheFetchRequest {
271 ///Run the command asynchronously. Returns a job id immediately.
272 #[serde(
273 rename = "_async",
274 default,
275 skip_serializing_if = "::std::option::Option::is_none"
276 )]
277 pub async_: ::std::option::Option<bool>,
278 ///Comma-separated chunk specifier list (e.g. `0:10,25:30`) describing
279 /// file pieces to prefetch.
280 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
281 pub chunks: ::std::option::Option<::std::string::String>,
282 ///Assign the request to a custom stats group.
283 #[serde(
284 rename = "_group",
285 default,
286 skip_serializing_if = "::std::option::Option::is_none"
287 )]
288 pub group: ::std::option::Option<::std::string::String>,
289 }
290
291 impl ::std::convert::From<&CacheFetchRequest> for CacheFetchRequest {
292 fn from(value: &CacheFetchRequest) -> Self {
293 value.clone()
294 }
295 }
296
297 impl ::std::default::Default for CacheFetchRequest {
298 fn default() -> Self {
299 Self {
300 async_: Default::default(),
301 chunks: Default::default(),
302 group: Default::default(),
303 }
304 }
305 }
306
307 ///`CacheStatsRequest`
308 ///
309 /// <details><summary>JSON schema</summary>
310 ///
311 /// ```json
312 ///{
313 /// "type": "object",
314 /// "properties": {
315 /// "_async": {
316 /// "description": "Run the command asynchronously. Returns a job id
317 /// immediately.",
318 /// "type": "boolean"
319 /// },
320 /// "_group": {
321 /// "description": "Assign the request to a custom stats group.",
322 /// "type": "string"
323 /// }
324 /// }
325 ///}
326 /// ```
327 /// </details>
328 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
329 pub struct CacheStatsRequest {
330 ///Run the command asynchronously. Returns a job id immediately.
331 #[serde(
332 rename = "_async",
333 default,
334 skip_serializing_if = "::std::option::Option::is_none"
335 )]
336 pub async_: ::std::option::Option<bool>,
337 ///Assign the request to a custom stats group.
338 #[serde(
339 rename = "_group",
340 default,
341 skip_serializing_if = "::std::option::Option::is_none"
342 )]
343 pub group: ::std::option::Option<::std::string::String>,
344 }
345
346 impl ::std::convert::From<&CacheStatsRequest> for CacheStatsRequest {
347 fn from(value: &CacheStatsRequest) -> Self {
348 value.clone()
349 }
350 }
351
352 impl ::std::default::Default for CacheStatsRequest {
353 fn default() -> Self {
354 Self {
355 async_: Default::default(),
356 group: Default::default(),
357 }
358 }
359 }
360
361 ///`ConfigCreateRequest`
362 ///
363 /// <details><summary>JSON schema</summary>
364 ///
365 /// ```json
366 ///{
367 /// "type": "object",
368 /// "properties": {
369 /// "_async": {
370 /// "description": "Run the command asynchronously. Returns a job id
371 /// immediately.",
372 /// "type": "boolean"
373 /// },
374 /// "_group": {
375 /// "description": "Assign the request to a custom stats group.",
376 /// "type": "string"
377 /// },
378 /// "name": {
379 /// "description": "Name of the new remote configuration.",
380 /// "type": "string"
381 /// },
382 /// "opt": {
383 /// "description": "Optional JSON object controlling interactive
384 /// behaviour (e.g. `obscure`, `continue`).",
385 /// "type": "string"
386 /// },
387 /// "parameters": {
388 /// "description": "JSON object of configuration key/value pairs
389 /// required for the remote.",
390 /// "type": "string"
391 /// },
392 /// "type": {
393 /// "description": "Backend type identifier, such as `drive`, `s3`, or
394 /// `dropbox`.",
395 /// "type": "string"
396 /// }
397 /// }
398 ///}
399 /// ```
400 /// </details>
401 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
402 pub struct ConfigCreateRequest {
403 ///Run the command asynchronously. Returns a job id immediately.
404 #[serde(
405 rename = "_async",
406 default,
407 skip_serializing_if = "::std::option::Option::is_none"
408 )]
409 pub async_: ::std::option::Option<bool>,
410 ///Assign the request to a custom stats group.
411 #[serde(
412 rename = "_group",
413 default,
414 skip_serializing_if = "::std::option::Option::is_none"
415 )]
416 pub group: ::std::option::Option<::std::string::String>,
417 ///Name of the new remote configuration.
418 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
419 pub name: ::std::option::Option<::std::string::String>,
420 ///Optional JSON object controlling interactive behaviour (e.g.
421 /// `obscure`, `continue`).
422 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
423 pub opt: ::std::option::Option<::std::string::String>,
424 ///JSON object of configuration key/value pairs required for the
425 /// remote.
426 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
427 pub parameters: ::std::option::Option<::std::string::String>,
428 ///Backend type identifier, such as `drive`, `s3`, or `dropbox`.
429 #[serde(
430 rename = "type",
431 default,
432 skip_serializing_if = "::std::option::Option::is_none"
433 )]
434 pub type_: ::std::option::Option<::std::string::String>,
435 }
436
437 impl ::std::convert::From<&ConfigCreateRequest> for ConfigCreateRequest {
438 fn from(value: &ConfigCreateRequest) -> Self {
439 value.clone()
440 }
441 }
442
443 impl ::std::default::Default for ConfigCreateRequest {
444 fn default() -> Self {
445 Self {
446 async_: Default::default(),
447 group: Default::default(),
448 name: Default::default(),
449 opt: Default::default(),
450 parameters: Default::default(),
451 type_: Default::default(),
452 }
453 }
454 }
455
456 ///`ConfigCreateResponse`
457 ///
458 /// <details><summary>JSON schema</summary>
459 ///
460 /// ```json
461 ///{
462 /// "type": "object",
463 /// "properties": {
464 /// "jobid": {
465 /// "description": "Job ID returned when _async=true.",
466 /// "type": "integer"
467 /// }
468 /// },
469 /// "additionalProperties": true
470 ///}
471 /// ```
472 /// </details>
473 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
474 pub struct ConfigCreateResponse {
475 ///Job ID returned when _async=true.
476 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
477 pub jobid: ::std::option::Option<i64>,
478 }
479
480 impl ::std::convert::From<&ConfigCreateResponse> for ConfigCreateResponse {
481 fn from(value: &ConfigCreateResponse) -> Self {
482 value.clone()
483 }
484 }
485
486 impl ::std::default::Default for ConfigCreateResponse {
487 fn default() -> Self {
488 Self {
489 jobid: Default::default(),
490 }
491 }
492 }
493
494 ///`ConfigDeleteRequest`
495 ///
496 /// <details><summary>JSON schema</summary>
497 ///
498 /// ```json
499 ///{
500 /// "type": "object",
501 /// "properties": {
502 /// "_async": {
503 /// "description": "Run the command asynchronously. Returns a job id
504 /// immediately.",
505 /// "type": "boolean"
506 /// },
507 /// "_group": {
508 /// "description": "Assign the request to a custom stats group.",
509 /// "type": "string"
510 /// },
511 /// "name": {
512 /// "description": "Name of the remote configuration to delete.",
513 /// "type": "string"
514 /// }
515 /// }
516 ///}
517 /// ```
518 /// </details>
519 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
520 pub struct ConfigDeleteRequest {
521 ///Run the command asynchronously. Returns a job id immediately.
522 #[serde(
523 rename = "_async",
524 default,
525 skip_serializing_if = "::std::option::Option::is_none"
526 )]
527 pub async_: ::std::option::Option<bool>,
528 ///Assign the request to a custom stats group.
529 #[serde(
530 rename = "_group",
531 default,
532 skip_serializing_if = "::std::option::Option::is_none"
533 )]
534 pub group: ::std::option::Option<::std::string::String>,
535 ///Name of the remote configuration to delete.
536 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
537 pub name: ::std::option::Option<::std::string::String>,
538 }
539
540 impl ::std::convert::From<&ConfigDeleteRequest> for ConfigDeleteRequest {
541 fn from(value: &ConfigDeleteRequest) -> Self {
542 value.clone()
543 }
544 }
545
546 impl ::std::default::Default for ConfigDeleteRequest {
547 fn default() -> Self {
548 Self {
549 async_: Default::default(),
550 group: Default::default(),
551 name: Default::default(),
552 }
553 }
554 }
555
556 ///`ConfigDumpRequest`
557 ///
558 /// <details><summary>JSON schema</summary>
559 ///
560 /// ```json
561 ///{
562 /// "type": "object",
563 /// "properties": {
564 /// "_async": {
565 /// "description": "Run the command asynchronously. Returns a job id
566 /// immediately.",
567 /// "type": "boolean"
568 /// },
569 /// "_group": {
570 /// "description": "Assign the request to a custom stats group.",
571 /// "type": "string"
572 /// }
573 /// }
574 ///}
575 /// ```
576 /// </details>
577 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
578 pub struct ConfigDumpRequest {
579 ///Run the command asynchronously. Returns a job id immediately.
580 #[serde(
581 rename = "_async",
582 default,
583 skip_serializing_if = "::std::option::Option::is_none"
584 )]
585 pub async_: ::std::option::Option<bool>,
586 ///Assign the request to a custom stats group.
587 #[serde(
588 rename = "_group",
589 default,
590 skip_serializing_if = "::std::option::Option::is_none"
591 )]
592 pub group: ::std::option::Option<::std::string::String>,
593 }
594
595 impl ::std::convert::From<&ConfigDumpRequest> for ConfigDumpRequest {
596 fn from(value: &ConfigDumpRequest) -> Self {
597 value.clone()
598 }
599 }
600
601 impl ::std::default::Default for ConfigDumpRequest {
602 fn default() -> Self {
603 Self {
604 async_: Default::default(),
605 group: Default::default(),
606 }
607 }
608 }
609
610 ///`ConfigGetRequest`
611 ///
612 /// <details><summary>JSON schema</summary>
613 ///
614 /// ```json
615 ///{
616 /// "type": "object",
617 /// "properties": {
618 /// "_async": {
619 /// "description": "Run the command asynchronously. Returns a job id
620 /// immediately.",
621 /// "type": "boolean"
622 /// },
623 /// "_group": {
624 /// "description": "Assign the request to a custom stats group.",
625 /// "type": "string"
626 /// },
627 /// "name": {
628 /// "description": "Name of the remote configuration to fetch.",
629 /// "type": "string"
630 /// }
631 /// }
632 ///}
633 /// ```
634 /// </details>
635 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
636 pub struct ConfigGetRequest {
637 ///Run the command asynchronously. Returns a job id immediately.
638 #[serde(
639 rename = "_async",
640 default,
641 skip_serializing_if = "::std::option::Option::is_none"
642 )]
643 pub async_: ::std::option::Option<bool>,
644 ///Assign the request to a custom stats group.
645 #[serde(
646 rename = "_group",
647 default,
648 skip_serializing_if = "::std::option::Option::is_none"
649 )]
650 pub group: ::std::option::Option<::std::string::String>,
651 ///Name of the remote configuration to fetch.
652 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
653 pub name: ::std::option::Option<::std::string::String>,
654 }
655
656 impl ::std::convert::From<&ConfigGetRequest> for ConfigGetRequest {
657 fn from(value: &ConfigGetRequest) -> Self {
658 value.clone()
659 }
660 }
661
662 impl ::std::default::Default for ConfigGetRequest {
663 fn default() -> Self {
664 Self {
665 async_: Default::default(),
666 group: Default::default(),
667 name: Default::default(),
668 }
669 }
670 }
671
672 ///`ConfigGetResponse`
673 ///
674 /// <details><summary>JSON schema</summary>
675 ///
676 /// ```json
677 ///{
678 /// "type": "object",
679 /// "required": [
680 /// "type"
681 /// ],
682 /// "properties": {
683 /// "type": {
684 /// "type": "string"
685 /// }
686 /// },
687 /// "additionalProperties": {
688 /// "type": "string"
689 /// }
690 ///}
691 /// ```
692 /// </details>
693 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
694 pub struct ConfigGetResponse {
695 #[serde(rename = "type")]
696 pub type_: ::std::string::String,
697 #[serde(flatten)]
698 pub extra: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
699 }
700
701 impl ::std::convert::From<&ConfigGetResponse> for ConfigGetResponse {
702 fn from(value: &ConfigGetResponse) -> Self {
703 value.clone()
704 }
705 }
706
707 ///`ConfigListremotesRequest`
708 ///
709 /// <details><summary>JSON schema</summary>
710 ///
711 /// ```json
712 ///{
713 /// "type": "object",
714 /// "properties": {
715 /// "_async": {
716 /// "description": "Run the command asynchronously. Returns a job id
717 /// immediately.",
718 /// "type": "boolean"
719 /// },
720 /// "_group": {
721 /// "description": "Assign the request to a custom stats group.",
722 /// "type": "string"
723 /// }
724 /// }
725 ///}
726 /// ```
727 /// </details>
728 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
729 pub struct ConfigListremotesRequest {
730 ///Run the command asynchronously. Returns a job id immediately.
731 #[serde(
732 rename = "_async",
733 default,
734 skip_serializing_if = "::std::option::Option::is_none"
735 )]
736 pub async_: ::std::option::Option<bool>,
737 ///Assign the request to a custom stats group.
738 #[serde(
739 rename = "_group",
740 default,
741 skip_serializing_if = "::std::option::Option::is_none"
742 )]
743 pub group: ::std::option::Option<::std::string::String>,
744 }
745
746 impl ::std::convert::From<&ConfigListremotesRequest> for ConfigListremotesRequest {
747 fn from(value: &ConfigListremotesRequest) -> Self {
748 value.clone()
749 }
750 }
751
752 impl ::std::default::Default for ConfigListremotesRequest {
753 fn default() -> Self {
754 Self {
755 async_: Default::default(),
756 group: Default::default(),
757 }
758 }
759 }
760
761 ///`ConfigListremotesResponse`
762 ///
763 /// <details><summary>JSON schema</summary>
764 ///
765 /// ```json
766 ///{
767 /// "type": "object",
768 /// "required": [
769 /// "remotes"
770 /// ],
771 /// "properties": {
772 /// "remotes": {
773 /// "type": "array",
774 /// "items": {
775 /// "type": "string"
776 /// }
777 /// }
778 /// }
779 ///}
780 /// ```
781 /// </details>
782 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
783 pub struct ConfigListremotesResponse {
784 pub remotes: ::std::vec::Vec<::std::string::String>,
785 }
786
787 impl ::std::convert::From<&ConfigListremotesResponse> for ConfigListremotesResponse {
788 fn from(value: &ConfigListremotesResponse) -> Self {
789 value.clone()
790 }
791 }
792
793 ///`ConfigPasswordRequest`
794 ///
795 /// <details><summary>JSON schema</summary>
796 ///
797 /// ```json
798 ///{
799 /// "type": "object",
800 /// "properties": {
801 /// "_async": {
802 /// "description": "Run the command asynchronously. Returns a job id
803 /// immediately.",
804 /// "type": "boolean"
805 /// },
806 /// "_group": {
807 /// "description": "Assign the request to a custom stats group.",
808 /// "type": "string"
809 /// },
810 /// "name": {
811 /// "description": "Name of the remote whose secrets should be
812 /// updated.",
813 /// "type": "string"
814 /// },
815 /// "parameters": {
816 /// "description": "JSON object of password answers, typically
817 /// including `pass`.",
818 /// "type": "string"
819 /// }
820 /// }
821 ///}
822 /// ```
823 /// </details>
824 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
825 pub struct ConfigPasswordRequest {
826 ///Run the command asynchronously. Returns a job id immediately.
827 #[serde(
828 rename = "_async",
829 default,
830 skip_serializing_if = "::std::option::Option::is_none"
831 )]
832 pub async_: ::std::option::Option<bool>,
833 ///Assign the request to a custom stats group.
834 #[serde(
835 rename = "_group",
836 default,
837 skip_serializing_if = "::std::option::Option::is_none"
838 )]
839 pub group: ::std::option::Option<::std::string::String>,
840 ///Name of the remote whose secrets should be updated.
841 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
842 pub name: ::std::option::Option<::std::string::String>,
843 ///JSON object of password answers, typically including `pass`.
844 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
845 pub parameters: ::std::option::Option<::std::string::String>,
846 }
847
848 impl ::std::convert::From<&ConfigPasswordRequest> for ConfigPasswordRequest {
849 fn from(value: &ConfigPasswordRequest) -> Self {
850 value.clone()
851 }
852 }
853
854 impl ::std::default::Default for ConfigPasswordRequest {
855 fn default() -> Self {
856 Self {
857 async_: Default::default(),
858 group: Default::default(),
859 name: Default::default(),
860 parameters: Default::default(),
861 }
862 }
863 }
864
865 ///`ConfigPathsRequest`
866 ///
867 /// <details><summary>JSON schema</summary>
868 ///
869 /// ```json
870 ///{
871 /// "type": "object",
872 /// "properties": {
873 /// "_async": {
874 /// "description": "Run the command asynchronously. Returns a job id
875 /// immediately.",
876 /// "type": "boolean"
877 /// },
878 /// "_group": {
879 /// "description": "Assign the request to a custom stats group.",
880 /// "type": "string"
881 /// }
882 /// }
883 ///}
884 /// ```
885 /// </details>
886 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
887 pub struct ConfigPathsRequest {
888 ///Run the command asynchronously. Returns a job id immediately.
889 #[serde(
890 rename = "_async",
891 default,
892 skip_serializing_if = "::std::option::Option::is_none"
893 )]
894 pub async_: ::std::option::Option<bool>,
895 ///Assign the request to a custom stats group.
896 #[serde(
897 rename = "_group",
898 default,
899 skip_serializing_if = "::std::option::Option::is_none"
900 )]
901 pub group: ::std::option::Option<::std::string::String>,
902 }
903
904 impl ::std::convert::From<&ConfigPathsRequest> for ConfigPathsRequest {
905 fn from(value: &ConfigPathsRequest) -> Self {
906 value.clone()
907 }
908 }
909
910 impl ::std::default::Default for ConfigPathsRequest {
911 fn default() -> Self {
912 Self {
913 async_: Default::default(),
914 group: Default::default(),
915 }
916 }
917 }
918
919 ///`ConfigPathsResponse`
920 ///
921 /// <details><summary>JSON schema</summary>
922 ///
923 /// ```json
924 ///{
925 /// "type": "object",
926 /// "required": [
927 /// "cache",
928 /// "config",
929 /// "temp"
930 /// ],
931 /// "properties": {
932 /// "cache": {
933 /// "type": "string"
934 /// },
935 /// "config": {
936 /// "type": "string"
937 /// },
938 /// "temp": {
939 /// "type": "string"
940 /// }
941 /// }
942 ///}
943 /// ```
944 /// </details>
945 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
946 pub struct ConfigPathsResponse {
947 pub cache: ::std::string::String,
948 pub config: ::std::string::String,
949 pub temp: ::std::string::String,
950 }
951
952 impl ::std::convert::From<&ConfigPathsResponse> for ConfigPathsResponse {
953 fn from(value: &ConfigPathsResponse) -> Self {
954 value.clone()
955 }
956 }
957
958 ///`ConfigProvider`
959 ///
960 /// <details><summary>JSON schema</summary>
961 ///
962 /// ```json
963 ///{
964 /// "type": "object",
965 /// "required": [
966 /// "Description",
967 /// "Name",
968 /// "Options",
969 /// "Prefix"
970 /// ],
971 /// "properties": {
972 /// "Aliases": {
973 /// "type": [
974 /// "array",
975 /// "null"
976 /// ],
977 /// "items": {
978 /// "type": "string"
979 /// }
980 /// },
981 /// "CommandHelp": {
982 /// "type": [
983 /// "array",
984 /// "null"
985 /// ],
986 /// "items": {
987 /// "$ref": "#/components/schemas/ConfigProviderCommandHelp"
988 /// }
989 /// },
990 /// "Description": {
991 /// "type": "string"
992 /// },
993 /// "Hide": {
994 /// "type": "boolean"
995 /// },
996 /// "MetadataInfo": {
997 /// "$ref": "#/components/schemas/ConfigProviderMetadataInfo"
998 /// },
999 /// "Name": {
1000 /// "type": "string"
1001 /// },
1002 /// "Options": {
1003 /// "type": "array",
1004 /// "items": {
1005 /// "$ref": "#/components/schemas/ConfigProviderOption"
1006 /// }
1007 /// },
1008 /// "Prefix": {
1009 /// "type": "string"
1010 /// }
1011 /// },
1012 /// "additionalProperties": true
1013 ///}
1014 /// ```
1015 /// </details>
1016 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1017 pub struct ConfigProvider {
1018 #[serde(
1019 rename = "Aliases",
1020 default,
1021 skip_serializing_if = "::std::option::Option::is_none"
1022 )]
1023 pub aliases: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
1024 #[serde(
1025 rename = "CommandHelp",
1026 default,
1027 skip_serializing_if = "::std::option::Option::is_none"
1028 )]
1029 pub command_help: ::std::option::Option<::std::vec::Vec<ConfigProviderCommandHelp>>,
1030 #[serde(rename = "Description")]
1031 pub description: ::std::string::String,
1032 #[serde(
1033 rename = "Hide",
1034 default,
1035 skip_serializing_if = "::std::option::Option::is_none"
1036 )]
1037 pub hide: ::std::option::Option<bool>,
1038 #[serde(
1039 rename = "MetadataInfo",
1040 default,
1041 skip_serializing_if = "::std::option::Option::is_none"
1042 )]
1043 pub metadata_info: ::std::option::Option<ConfigProviderMetadataInfo>,
1044 #[serde(rename = "Name")]
1045 pub name: ::std::string::String,
1046 #[serde(rename = "Options")]
1047 pub options: ::std::vec::Vec<ConfigProviderOption>,
1048 #[serde(rename = "Prefix")]
1049 pub prefix: ::std::string::String,
1050 }
1051
1052 impl ::std::convert::From<&ConfigProvider> for ConfigProvider {
1053 fn from(value: &ConfigProvider) -> Self {
1054 value.clone()
1055 }
1056 }
1057
1058 ///`ConfigProviderCommandHelp`
1059 ///
1060 /// <details><summary>JSON schema</summary>
1061 ///
1062 /// ```json
1063 ///{
1064 /// "type": "object",
1065 /// "properties": {
1066 /// "Long": {
1067 /// "type": "string"
1068 /// },
1069 /// "Name": {
1070 /// "type": "string"
1071 /// },
1072 /// "Opts": {
1073 /// "type": [
1074 /// "object",
1075 /// "null"
1076 /// ],
1077 /// "additionalProperties": true
1078 /// },
1079 /// "Short": {
1080 /// "type": "string"
1081 /// }
1082 /// },
1083 /// "additionalProperties": true
1084 ///}
1085 /// ```
1086 /// </details>
1087 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1088 pub struct ConfigProviderCommandHelp {
1089 #[serde(
1090 rename = "Long",
1091 default,
1092 skip_serializing_if = "::std::option::Option::is_none"
1093 )]
1094 pub long: ::std::option::Option<::std::string::String>,
1095 #[serde(
1096 rename = "Name",
1097 default,
1098 skip_serializing_if = "::std::option::Option::is_none"
1099 )]
1100 pub name: ::std::option::Option<::std::string::String>,
1101 #[serde(
1102 rename = "Opts",
1103 default,
1104 skip_serializing_if = "::std::option::Option::is_none"
1105 )]
1106 pub opts:
1107 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
1108 #[serde(
1109 rename = "Short",
1110 default,
1111 skip_serializing_if = "::std::option::Option::is_none"
1112 )]
1113 pub short: ::std::option::Option<::std::string::String>,
1114 }
1115
1116 impl ::std::convert::From<&ConfigProviderCommandHelp> for ConfigProviderCommandHelp {
1117 fn from(value: &ConfigProviderCommandHelp) -> Self {
1118 value.clone()
1119 }
1120 }
1121
1122 impl ::std::default::Default for ConfigProviderCommandHelp {
1123 fn default() -> Self {
1124 Self {
1125 long: Default::default(),
1126 name: Default::default(),
1127 opts: Default::default(),
1128 short: Default::default(),
1129 }
1130 }
1131 }
1132
1133 ///`ConfigProviderMetadataInfo`
1134 ///
1135 /// <details><summary>JSON schema</summary>
1136 ///
1137 /// ```json
1138 ///{
1139 /// "type": "object",
1140 /// "properties": {
1141 /// "Help": {
1142 /// "type": "string"
1143 /// },
1144 /// "System": {
1145 /// "type": [
1146 /// "object",
1147 /// "null"
1148 /// ],
1149 /// "additionalProperties": {
1150 /// "$ref": "#/components/schemas/ConfigProviderMetadataSystemEntry"
1151 /// }
1152 /// }
1153 /// },
1154 /// "additionalProperties": true
1155 ///}
1156 /// ```
1157 /// </details>
1158 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1159 pub struct ConfigProviderMetadataInfo {
1160 #[serde(
1161 rename = "Help",
1162 default,
1163 skip_serializing_if = "::std::option::Option::is_none"
1164 )]
1165 pub help: ::std::option::Option<::std::string::String>,
1166 #[serde(
1167 rename = "System",
1168 default,
1169 skip_serializing_if = "::std::option::Option::is_none"
1170 )]
1171 pub system: ::std::option::Option<
1172 ::std::collections::HashMap<::std::string::String, ConfigProviderMetadataSystemEntry>,
1173 >,
1174 }
1175
1176 impl ::std::convert::From<&ConfigProviderMetadataInfo> for ConfigProviderMetadataInfo {
1177 fn from(value: &ConfigProviderMetadataInfo) -> Self {
1178 value.clone()
1179 }
1180 }
1181
1182 impl ::std::default::Default for ConfigProviderMetadataInfo {
1183 fn default() -> Self {
1184 Self {
1185 help: Default::default(),
1186 system: Default::default(),
1187 }
1188 }
1189 }
1190
1191 ///`ConfigProviderMetadataSystemEntry`
1192 ///
1193 /// <details><summary>JSON schema</summary>
1194 ///
1195 /// ```json
1196 ///{
1197 /// "type": "object",
1198 /// "properties": {
1199 /// "Example": {
1200 /// "type": "string"
1201 /// },
1202 /// "Help": {
1203 /// "type": "string"
1204 /// },
1205 /// "ReadOnly": {
1206 /// "type": "boolean"
1207 /// },
1208 /// "Type": {
1209 /// "type": "string"
1210 /// }
1211 /// },
1212 /// "additionalProperties": true
1213 ///}
1214 /// ```
1215 /// </details>
1216 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1217 pub struct ConfigProviderMetadataSystemEntry {
1218 #[serde(
1219 rename = "Example",
1220 default,
1221 skip_serializing_if = "::std::option::Option::is_none"
1222 )]
1223 pub example: ::std::option::Option<::std::string::String>,
1224 #[serde(
1225 rename = "Help",
1226 default,
1227 skip_serializing_if = "::std::option::Option::is_none"
1228 )]
1229 pub help: ::std::option::Option<::std::string::String>,
1230 #[serde(
1231 rename = "ReadOnly",
1232 default,
1233 skip_serializing_if = "::std::option::Option::is_none"
1234 )]
1235 pub read_only: ::std::option::Option<bool>,
1236 #[serde(
1237 rename = "Type",
1238 default,
1239 skip_serializing_if = "::std::option::Option::is_none"
1240 )]
1241 pub type_: ::std::option::Option<::std::string::String>,
1242 }
1243
1244 impl ::std::convert::From<&ConfigProviderMetadataSystemEntry>
1245 for ConfigProviderMetadataSystemEntry
1246 {
1247 fn from(value: &ConfigProviderMetadataSystemEntry) -> Self {
1248 value.clone()
1249 }
1250 }
1251
1252 impl ::std::default::Default for ConfigProviderMetadataSystemEntry {
1253 fn default() -> Self {
1254 Self {
1255 example: Default::default(),
1256 help: Default::default(),
1257 read_only: Default::default(),
1258 type_: Default::default(),
1259 }
1260 }
1261 }
1262
1263 ///`ConfigProviderOption`
1264 ///
1265 /// <details><summary>JSON schema</summary>
1266 ///
1267 /// ```json
1268 ///{
1269 /// "type": "object",
1270 /// "required": [
1271 /// "Advanced",
1272 /// "Default",
1273 /// "DefaultStr",
1274 /// "Exclusive",
1275 /// "FieldName",
1276 /// "Help",
1277 /// "Hide",
1278 /// "IsPassword",
1279 /// "Name",
1280 /// "NoPrefix",
1281 /// "Required",
1282 /// "Sensitive",
1283 /// "Type",
1284 /// "Value",
1285 /// "ValueStr"
1286 /// ],
1287 /// "properties": {
1288 /// "Advanced": {
1289 /// "type": "boolean"
1290 /// },
1291 /// "Default": {
1292 /// "$ref": "#/components/schemas/ConfigProviderOptionAny"
1293 /// },
1294 /// "DefaultStr": {
1295 /// "type": "string"
1296 /// },
1297 /// "Examples": {
1298 /// "type": "array",
1299 /// "items": {
1300 /// "$ref": "#/components/schemas/ConfigProviderOptionExample"
1301 /// }
1302 /// },
1303 /// "Exclusive": {
1304 /// "type": "boolean"
1305 /// },
1306 /// "FieldName": {
1307 /// "type": "string"
1308 /// },
1309 /// "Help": {
1310 /// "type": "string"
1311 /// },
1312 /// "Hide": {
1313 /// "type": "number"
1314 /// },
1315 /// "IsPassword": {
1316 /// "type": "boolean"
1317 /// },
1318 /// "Name": {
1319 /// "type": "string"
1320 /// },
1321 /// "NoPrefix": {
1322 /// "type": "boolean"
1323 /// },
1324 /// "Provider": {
1325 /// "type": "string"
1326 /// },
1327 /// "Required": {
1328 /// "type": "boolean"
1329 /// },
1330 /// "Sensitive": {
1331 /// "type": "boolean"
1332 /// },
1333 /// "ShortOpt": {
1334 /// "type": "string"
1335 /// },
1336 /// "Type": {
1337 /// "$ref": "#/components/schemas/ConfigProviderOptionType"
1338 /// },
1339 /// "Value": {
1340 /// "$ref": "#/components/schemas/ConfigProviderOptionAny"
1341 /// },
1342 /// "ValueStr": {
1343 /// "type": "string"
1344 /// }
1345 /// },
1346 /// "additionalProperties": true
1347 ///}
1348 /// ```
1349 /// </details>
1350 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1351 pub struct ConfigProviderOption {
1352 #[serde(rename = "Advanced")]
1353 pub advanced: bool,
1354 #[serde(rename = "Default")]
1355 pub default: ConfigProviderOptionAny,
1356 #[serde(rename = "DefaultStr")]
1357 pub default_str: ::std::string::String,
1358 #[serde(
1359 rename = "Examples",
1360 default,
1361 skip_serializing_if = "::std::vec::Vec::is_empty"
1362 )]
1363 pub examples: ::std::vec::Vec<ConfigProviderOptionExample>,
1364 #[serde(rename = "Exclusive")]
1365 pub exclusive: bool,
1366 #[serde(rename = "FieldName")]
1367 pub field_name: ::std::string::String,
1368 #[serde(rename = "Help")]
1369 pub help: ::std::string::String,
1370 #[serde(rename = "Hide")]
1371 pub hide: f64,
1372 #[serde(rename = "IsPassword")]
1373 pub is_password: bool,
1374 #[serde(rename = "Name")]
1375 pub name: ::std::string::String,
1376 #[serde(rename = "NoPrefix")]
1377 pub no_prefix: bool,
1378 #[serde(
1379 rename = "Provider",
1380 default,
1381 skip_serializing_if = "::std::option::Option::is_none"
1382 )]
1383 pub provider: ::std::option::Option<::std::string::String>,
1384 #[serde(rename = "Required")]
1385 pub required: bool,
1386 #[serde(rename = "Sensitive")]
1387 pub sensitive: bool,
1388 #[serde(
1389 rename = "ShortOpt",
1390 default,
1391 skip_serializing_if = "::std::option::Option::is_none"
1392 )]
1393 pub short_opt: ::std::option::Option<::std::string::String>,
1394 #[serde(rename = "Type")]
1395 pub type_: ConfigProviderOptionType,
1396 #[serde(rename = "Value")]
1397 pub value: ConfigProviderOptionAny,
1398 #[serde(rename = "ValueStr")]
1399 pub value_str: ::std::string::String,
1400 }
1401
1402 impl ::std::convert::From<&ConfigProviderOption> for ConfigProviderOption {
1403 fn from(value: &ConfigProviderOption) -> Self {
1404 value.clone()
1405 }
1406 }
1407
1408 ///Arbitrary JSON value. (arbitrary JSON value)
1409 ///
1410 /// <details><summary>JSON schema</summary>
1411 ///
1412 /// ```json
1413 ///{
1414 /// "description": "Arbitrary JSON value. (arbitrary JSON value)",
1415 /// "type": [
1416 /// "object",
1417 /// "null"
1418 /// ],
1419 /// "additionalProperties": true
1420 ///}
1421 /// ```
1422 /// </details>
1423 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1424 #[serde(transparent)]
1425 pub struct ConfigProviderOptionAny(
1426 pub ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
1427 );
1428 impl ::std::ops::Deref for ConfigProviderOptionAny {
1429 type Target =
1430 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>;
1431 fn deref(
1432 &self,
1433 ) -> &::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
1434 {
1435 &self.0
1436 }
1437 }
1438
1439 impl ::std::convert::From<ConfigProviderOptionAny>
1440 for ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
1441 {
1442 fn from(value: ConfigProviderOptionAny) -> Self {
1443 value.0
1444 }
1445 }
1446
1447 impl ::std::convert::From<&ConfigProviderOptionAny> for ConfigProviderOptionAny {
1448 fn from(value: &ConfigProviderOptionAny) -> Self {
1449 value.clone()
1450 }
1451 }
1452
1453 impl
1454 ::std::convert::From<
1455 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
1456 > for ConfigProviderOptionAny
1457 {
1458 fn from(
1459 value: ::std::option::Option<
1460 ::serde_json::Map<::std::string::String, ::serde_json::Value>,
1461 >,
1462 ) -> Self {
1463 Self(value)
1464 }
1465 }
1466
1467 ///`ConfigProviderOptionExample`
1468 ///
1469 /// <details><summary>JSON schema</summary>
1470 ///
1471 /// ```json
1472 ///{
1473 /// "type": "object",
1474 /// "required": [
1475 /// "Help",
1476 /// "Value"
1477 /// ],
1478 /// "properties": {
1479 /// "Help": {
1480 /// "type": "string"
1481 /// },
1482 /// "Provider": {
1483 /// "type": "string"
1484 /// },
1485 /// "Value": {
1486 /// "type": "string"
1487 /// }
1488 /// },
1489 /// "additionalProperties": true
1490 ///}
1491 /// ```
1492 /// </details>
1493 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1494 pub struct ConfigProviderOptionExample {
1495 #[serde(rename = "Help")]
1496 pub help: ::std::string::String,
1497 #[serde(
1498 rename = "Provider",
1499 default,
1500 skip_serializing_if = "::std::option::Option::is_none"
1501 )]
1502 pub provider: ::std::option::Option<::std::string::String>,
1503 #[serde(rename = "Value")]
1504 pub value: ::std::string::String,
1505 }
1506
1507 impl ::std::convert::From<&ConfigProviderOptionExample> for ConfigProviderOptionExample {
1508 fn from(value: &ConfigProviderOptionExample) -> Self {
1509 value.clone()
1510 }
1511 }
1512
1513 ///`ConfigProviderOptionType`
1514 ///
1515 /// <details><summary>JSON schema</summary>
1516 ///
1517 /// ```json
1518 ///{
1519 /// "type": "string",
1520 /// "enum": [
1521 /// "Bits",
1522 /// "bool",
1523 /// "CommaSepList",
1524 /// "Duration",
1525 /// "Encoding",
1526 /// "int",
1527 /// "mtime|atime|btime|ctime",
1528 /// "SizeSuffix",
1529 /// "SpaceSepList",
1530 /// "string",
1531 /// "stringArray",
1532 /// "Time",
1533 /// "Tristate"
1534 /// ]
1535 ///}
1536 /// ```
1537 /// </details>
1538 #[derive(
1539 :: serde :: Deserialize,
1540 :: serde :: Serialize,
1541 Clone,
1542 Copy,
1543 Debug,
1544 Eq,
1545 Hash,
1546 Ord,
1547 PartialEq,
1548 PartialOrd,
1549 )]
1550 pub enum ConfigProviderOptionType {
1551 Bits,
1552 #[serde(rename = "bool")]
1553 Bool,
1554 CommaSepList,
1555 Duration,
1556 Encoding,
1557 #[serde(rename = "int")]
1558 Int,
1559 #[serde(rename = "mtime|atime|btime|ctime")]
1560 MtimeAtimeBtimeCtime,
1561 SizeSuffix,
1562 SpaceSepList,
1563 #[serde(rename = "string")]
1564 String,
1565 #[serde(rename = "stringArray")]
1566 StringArray,
1567 Time,
1568 Tristate,
1569 }
1570
1571 impl ::std::convert::From<&Self> for ConfigProviderOptionType {
1572 fn from(value: &ConfigProviderOptionType) -> Self {
1573 value.clone()
1574 }
1575 }
1576
1577 impl ::std::fmt::Display for ConfigProviderOptionType {
1578 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1579 match *self {
1580 Self::Bits => f.write_str("Bits"),
1581 Self::Bool => f.write_str("bool"),
1582 Self::CommaSepList => f.write_str("CommaSepList"),
1583 Self::Duration => f.write_str("Duration"),
1584 Self::Encoding => f.write_str("Encoding"),
1585 Self::Int => f.write_str("int"),
1586 Self::MtimeAtimeBtimeCtime => f.write_str("mtime|atime|btime|ctime"),
1587 Self::SizeSuffix => f.write_str("SizeSuffix"),
1588 Self::SpaceSepList => f.write_str("SpaceSepList"),
1589 Self::String => f.write_str("string"),
1590 Self::StringArray => f.write_str("stringArray"),
1591 Self::Time => f.write_str("Time"),
1592 Self::Tristate => f.write_str("Tristate"),
1593 }
1594 }
1595 }
1596
1597 impl ::std::str::FromStr for ConfigProviderOptionType {
1598 type Err = self::error::ConversionError;
1599 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1600 match value {
1601 "Bits" => Ok(Self::Bits),
1602 "bool" => Ok(Self::Bool),
1603 "CommaSepList" => Ok(Self::CommaSepList),
1604 "Duration" => Ok(Self::Duration),
1605 "Encoding" => Ok(Self::Encoding),
1606 "int" => Ok(Self::Int),
1607 "mtime|atime|btime|ctime" => Ok(Self::MtimeAtimeBtimeCtime),
1608 "SizeSuffix" => Ok(Self::SizeSuffix),
1609 "SpaceSepList" => Ok(Self::SpaceSepList),
1610 "string" => Ok(Self::String),
1611 "stringArray" => Ok(Self::StringArray),
1612 "Time" => Ok(Self::Time),
1613 "Tristate" => Ok(Self::Tristate),
1614 _ => Err("invalid value".into()),
1615 }
1616 }
1617 }
1618
1619 impl ::std::convert::TryFrom<&str> for ConfigProviderOptionType {
1620 type Error = self::error::ConversionError;
1621 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1622 value.parse()
1623 }
1624 }
1625
1626 impl ::std::convert::TryFrom<&::std::string::String> for ConfigProviderOptionType {
1627 type Error = self::error::ConversionError;
1628 fn try_from(
1629 value: &::std::string::String,
1630 ) -> ::std::result::Result<Self, self::error::ConversionError> {
1631 value.parse()
1632 }
1633 }
1634
1635 impl ::std::convert::TryFrom<::std::string::String> for ConfigProviderOptionType {
1636 type Error = self::error::ConversionError;
1637 fn try_from(
1638 value: ::std::string::String,
1639 ) -> ::std::result::Result<Self, self::error::ConversionError> {
1640 value.parse()
1641 }
1642 }
1643
1644 ///`ConfigProvidersRequest`
1645 ///
1646 /// <details><summary>JSON schema</summary>
1647 ///
1648 /// ```json
1649 ///{
1650 /// "type": "object",
1651 /// "properties": {
1652 /// "_async": {
1653 /// "description": "Run the command asynchronously. Returns a job id
1654 /// immediately.",
1655 /// "type": "boolean"
1656 /// },
1657 /// "_group": {
1658 /// "description": "Assign the request to a custom stats group.",
1659 /// "type": "string"
1660 /// }
1661 /// }
1662 ///}
1663 /// ```
1664 /// </details>
1665 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1666 pub struct ConfigProvidersRequest {
1667 ///Run the command asynchronously. Returns a job id immediately.
1668 #[serde(
1669 rename = "_async",
1670 default,
1671 skip_serializing_if = "::std::option::Option::is_none"
1672 )]
1673 pub async_: ::std::option::Option<bool>,
1674 ///Assign the request to a custom stats group.
1675 #[serde(
1676 rename = "_group",
1677 default,
1678 skip_serializing_if = "::std::option::Option::is_none"
1679 )]
1680 pub group: ::std::option::Option<::std::string::String>,
1681 }
1682
1683 impl ::std::convert::From<&ConfigProvidersRequest> for ConfigProvidersRequest {
1684 fn from(value: &ConfigProvidersRequest) -> Self {
1685 value.clone()
1686 }
1687 }
1688
1689 impl ::std::default::Default for ConfigProvidersRequest {
1690 fn default() -> Self {
1691 Self {
1692 async_: Default::default(),
1693 group: Default::default(),
1694 }
1695 }
1696 }
1697
1698 ///`ConfigProvidersResponse`
1699 ///
1700 /// <details><summary>JSON schema</summary>
1701 ///
1702 /// ```json
1703 ///{
1704 /// "type": "object",
1705 /// "required": [
1706 /// "providers"
1707 /// ],
1708 /// "properties": {
1709 /// "providers": {
1710 /// "type": "array",
1711 /// "items": {
1712 /// "$ref": "#/components/schemas/ConfigProvider"
1713 /// }
1714 /// }
1715 /// },
1716 /// "additionalProperties": true
1717 ///}
1718 /// ```
1719 /// </details>
1720 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1721 pub struct ConfigProvidersResponse {
1722 pub providers: ::std::vec::Vec<ConfigProvider>,
1723 }
1724
1725 impl ::std::convert::From<&ConfigProvidersResponse> for ConfigProvidersResponse {
1726 fn from(value: &ConfigProvidersResponse) -> Self {
1727 value.clone()
1728 }
1729 }
1730
1731 ///`ConfigSetpathRequest`
1732 ///
1733 /// <details><summary>JSON schema</summary>
1734 ///
1735 /// ```json
1736 ///{
1737 /// "type": "object",
1738 /// "properties": {
1739 /// "_async": {
1740 /// "description": "Run the command asynchronously. Returns a job id
1741 /// immediately.",
1742 /// "type": "boolean"
1743 /// },
1744 /// "_group": {
1745 /// "description": "Assign the request to a custom stats group.",
1746 /// "type": "string"
1747 /// },
1748 /// "path": {
1749 /// "description": "Absolute path to the `rclone.conf` file that rclone
1750 /// should use.",
1751 /// "type": "string"
1752 /// }
1753 /// }
1754 ///}
1755 /// ```
1756 /// </details>
1757 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1758 pub struct ConfigSetpathRequest {
1759 ///Run the command asynchronously. Returns a job id immediately.
1760 #[serde(
1761 rename = "_async",
1762 default,
1763 skip_serializing_if = "::std::option::Option::is_none"
1764 )]
1765 pub async_: ::std::option::Option<bool>,
1766 ///Assign the request to a custom stats group.
1767 #[serde(
1768 rename = "_group",
1769 default,
1770 skip_serializing_if = "::std::option::Option::is_none"
1771 )]
1772 pub group: ::std::option::Option<::std::string::String>,
1773 ///Absolute path to the `rclone.conf` file that rclone should use.
1774 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1775 pub path: ::std::option::Option<::std::string::String>,
1776 }
1777
1778 impl ::std::convert::From<&ConfigSetpathRequest> for ConfigSetpathRequest {
1779 fn from(value: &ConfigSetpathRequest) -> Self {
1780 value.clone()
1781 }
1782 }
1783
1784 impl ::std::default::Default for ConfigSetpathRequest {
1785 fn default() -> Self {
1786 Self {
1787 async_: Default::default(),
1788 group: Default::default(),
1789 path: Default::default(),
1790 }
1791 }
1792 }
1793
1794 ///`ConfigUnlockRequest`
1795 ///
1796 /// <details><summary>JSON schema</summary>
1797 ///
1798 /// ```json
1799 ///{
1800 /// "type": "object",
1801 /// "properties": {
1802 /// "_async": {
1803 /// "description": "Run the command asynchronously. Returns a job id
1804 /// immediately.",
1805 /// "type": "boolean"
1806 /// },
1807 /// "_group": {
1808 /// "description": "Assign the request to a custom stats group.",
1809 /// "type": "string"
1810 /// },
1811 /// "configPassword": {
1812 /// "description": "Password used to unlock an encrypted config file.",
1813 /// "type": "string"
1814 /// }
1815 /// }
1816 ///}
1817 /// ```
1818 /// </details>
1819 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1820 pub struct ConfigUnlockRequest {
1821 ///Run the command asynchronously. Returns a job id immediately.
1822 #[serde(
1823 rename = "_async",
1824 default,
1825 skip_serializing_if = "::std::option::Option::is_none"
1826 )]
1827 pub async_: ::std::option::Option<bool>,
1828 ///Password used to unlock an encrypted config file.
1829 #[serde(
1830 rename = "configPassword",
1831 default,
1832 skip_serializing_if = "::std::option::Option::is_none"
1833 )]
1834 pub config_password: ::std::option::Option<::std::string::String>,
1835 ///Assign the request to a custom stats group.
1836 #[serde(
1837 rename = "_group",
1838 default,
1839 skip_serializing_if = "::std::option::Option::is_none"
1840 )]
1841 pub group: ::std::option::Option<::std::string::String>,
1842 }
1843
1844 impl ::std::convert::From<&ConfigUnlockRequest> for ConfigUnlockRequest {
1845 fn from(value: &ConfigUnlockRequest) -> Self {
1846 value.clone()
1847 }
1848 }
1849
1850 impl ::std::default::Default for ConfigUnlockRequest {
1851 fn default() -> Self {
1852 Self {
1853 async_: Default::default(),
1854 config_password: Default::default(),
1855 group: Default::default(),
1856 }
1857 }
1858 }
1859
1860 ///`ConfigUpdateRequest`
1861 ///
1862 /// <details><summary>JSON schema</summary>
1863 ///
1864 /// ```json
1865 ///{
1866 /// "type": "object",
1867 /// "properties": {
1868 /// "_async": {
1869 /// "description": "Run the command asynchronously. Returns a job id
1870 /// immediately.",
1871 /// "type": "boolean"
1872 /// },
1873 /// "_group": {
1874 /// "description": "Assign the request to a custom stats group.",
1875 /// "type": "string"
1876 /// },
1877 /// "name": {
1878 /// "description": "Name of the remote configuration to update.",
1879 /// "type": "string"
1880 /// },
1881 /// "opt": {
1882 /// "description": "Optional JSON object controlling update behaviour
1883 /// (e.g. `obscure`, `continue`).",
1884 /// "type": "string"
1885 /// },
1886 /// "parameters": {
1887 /// "description": "JSON object of configuration key/value pairs to
1888 /// apply to the remote.",
1889 /// "type": "string"
1890 /// }
1891 /// }
1892 ///}
1893 /// ```
1894 /// </details>
1895 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1896 pub struct ConfigUpdateRequest {
1897 ///Run the command asynchronously. Returns a job id immediately.
1898 #[serde(
1899 rename = "_async",
1900 default,
1901 skip_serializing_if = "::std::option::Option::is_none"
1902 )]
1903 pub async_: ::std::option::Option<bool>,
1904 ///Assign the request to a custom stats group.
1905 #[serde(
1906 rename = "_group",
1907 default,
1908 skip_serializing_if = "::std::option::Option::is_none"
1909 )]
1910 pub group: ::std::option::Option<::std::string::String>,
1911 ///Name of the remote configuration to update.
1912 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1913 pub name: ::std::option::Option<::std::string::String>,
1914 ///Optional JSON object controlling update behaviour (e.g. `obscure`,
1915 /// `continue`).
1916 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1917 pub opt: ::std::option::Option<::std::string::String>,
1918 ///JSON object of configuration key/value pairs to apply to the remote.
1919 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1920 pub parameters: ::std::option::Option<::std::string::String>,
1921 }
1922
1923 impl ::std::convert::From<&ConfigUpdateRequest> for ConfigUpdateRequest {
1924 fn from(value: &ConfigUpdateRequest) -> Self {
1925 value.clone()
1926 }
1927 }
1928
1929 impl ::std::default::Default for ConfigUpdateRequest {
1930 fn default() -> Self {
1931 Self {
1932 async_: Default::default(),
1933 group: Default::default(),
1934 name: Default::default(),
1935 opt: Default::default(),
1936 parameters: Default::default(),
1937 }
1938 }
1939 }
1940
1941 ///`ConfigUpdateResponse`
1942 ///
1943 /// <details><summary>JSON schema</summary>
1944 ///
1945 /// ```json
1946 ///{
1947 /// "type": "object",
1948 /// "properties": {
1949 /// "jobid": {
1950 /// "description": "Job ID returned when _async=true.",
1951 /// "type": "integer"
1952 /// }
1953 /// },
1954 /// "additionalProperties": true
1955 ///}
1956 /// ```
1957 /// </details>
1958 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1959 pub struct ConfigUpdateResponse {
1960 ///Job ID returned when _async=true.
1961 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1962 pub jobid: ::std::option::Option<i64>,
1963 }
1964
1965 impl ::std::convert::From<&ConfigUpdateResponse> for ConfigUpdateResponse {
1966 fn from(value: &ConfigUpdateResponse) -> Self {
1967 value.clone()
1968 }
1969 }
1970
1971 impl ::std::default::Default for ConfigUpdateResponse {
1972 fn default() -> Self {
1973 Self {
1974 jobid: Default::default(),
1975 }
1976 }
1977 }
1978
1979 ///`CoreBwlimitRequest`
1980 ///
1981 /// <details><summary>JSON schema</summary>
1982 ///
1983 /// ```json
1984 ///{
1985 /// "type": "object",
1986 /// "properties": {
1987 /// "_async": {
1988 /// "description": "Run the command asynchronously. Returns a job id
1989 /// immediately.",
1990 /// "type": "boolean"
1991 /// },
1992 /// "_group": {
1993 /// "description": "Assign the request to a custom stats group.",
1994 /// "type": "string"
1995 /// },
1996 /// "rate": {
1997 /// "description": "Bandwidth limit to apply, for example `off`, `5M`,
1998 /// or a schedule string.",
1999 /// "type": "string"
2000 /// }
2001 /// }
2002 ///}
2003 /// ```
2004 /// </details>
2005 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2006 pub struct CoreBwlimitRequest {
2007 ///Run the command asynchronously. Returns a job id immediately.
2008 #[serde(
2009 rename = "_async",
2010 default,
2011 skip_serializing_if = "::std::option::Option::is_none"
2012 )]
2013 pub async_: ::std::option::Option<bool>,
2014 ///Assign the request to a custom stats group.
2015 #[serde(
2016 rename = "_group",
2017 default,
2018 skip_serializing_if = "::std::option::Option::is_none"
2019 )]
2020 pub group: ::std::option::Option<::std::string::String>,
2021 ///Bandwidth limit to apply, for example `off`, `5M`, or a schedule
2022 /// string.
2023 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2024 pub rate: ::std::option::Option<::std::string::String>,
2025 }
2026
2027 impl ::std::convert::From<&CoreBwlimitRequest> for CoreBwlimitRequest {
2028 fn from(value: &CoreBwlimitRequest) -> Self {
2029 value.clone()
2030 }
2031 }
2032
2033 impl ::std::default::Default for CoreBwlimitRequest {
2034 fn default() -> Self {
2035 Self {
2036 async_: Default::default(),
2037 group: Default::default(),
2038 rate: Default::default(),
2039 }
2040 }
2041 }
2042
2043 ///`CoreBwlimitResponse`
2044 ///
2045 /// <details><summary>JSON schema</summary>
2046 ///
2047 /// ```json
2048 ///{
2049 /// "type": "object",
2050 /// "required": [
2051 /// "bytesPerSecond",
2052 /// "bytesPerSecondRx",
2053 /// "bytesPerSecondTx",
2054 /// "rate"
2055 /// ],
2056 /// "properties": {
2057 /// "bytesPerSecond": {
2058 /// "type": "integer"
2059 /// },
2060 /// "bytesPerSecondRx": {
2061 /// "type": "integer"
2062 /// },
2063 /// "bytesPerSecondTx": {
2064 /// "type": "integer"
2065 /// },
2066 /// "rate": {
2067 /// "type": "string"
2068 /// }
2069 /// }
2070 ///}
2071 /// ```
2072 /// </details>
2073 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2074 pub struct CoreBwlimitResponse {
2075 #[serde(rename = "bytesPerSecond")]
2076 pub bytes_per_second: i64,
2077 #[serde(rename = "bytesPerSecondRx")]
2078 pub bytes_per_second_rx: i64,
2079 #[serde(rename = "bytesPerSecondTx")]
2080 pub bytes_per_second_tx: i64,
2081 pub rate: ::std::string::String,
2082 }
2083
2084 impl ::std::convert::From<&CoreBwlimitResponse> for CoreBwlimitResponse {
2085 fn from(value: &CoreBwlimitResponse) -> Self {
2086 value.clone()
2087 }
2088 }
2089
2090 ///`CoreCommandRequest`
2091 ///
2092 /// <details><summary>JSON schema</summary>
2093 ///
2094 /// ```json
2095 ///{
2096 /// "type": "object",
2097 /// "properties": {
2098 /// "_async": {
2099 /// "description": "Run the command asynchronously. Returns a job id
2100 /// immediately.",
2101 /// "type": "boolean"
2102 /// },
2103 /// "_group": {
2104 /// "description": "Assign the request to a custom stats group.",
2105 /// "type": "string"
2106 /// },
2107 /// "arg": {
2108 /// "description": "Optional positional arguments for the command.
2109 /// Repeat to supply multiple values.",
2110 /// "type": "array",
2111 /// "items": {
2112 /// "type": "string"
2113 /// }
2114 /// },
2115 /// "command": {
2116 /// "description": "Name of the rclone command to execute, for example
2117 /// `ls` or `lsf`.",
2118 /// "type": "string"
2119 /// },
2120 /// "opt": {
2121 /// "description": "Optional command options encoded as a JSON
2122 /// string.",
2123 /// "type": "string"
2124 /// },
2125 /// "returnType": {
2126 /// "description": "Controls how output is returned; accepts
2127 /// `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
2128 /// `STREAM_ONLY_STDERR`.",
2129 /// "type": "string"
2130 /// }
2131 /// }
2132 ///}
2133 /// ```
2134 /// </details>
2135 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2136 pub struct CoreCommandRequest {
2137 ///Optional positional arguments for the command. Repeat to supply
2138 /// multiple values.
2139 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2140 pub arg: ::std::vec::Vec<::std::string::String>,
2141 ///Run the command asynchronously. Returns a job id immediately.
2142 #[serde(
2143 rename = "_async",
2144 default,
2145 skip_serializing_if = "::std::option::Option::is_none"
2146 )]
2147 pub async_: ::std::option::Option<bool>,
2148 ///Name of the rclone command to execute, for example `ls` or `lsf`.
2149 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2150 pub command: ::std::option::Option<::std::string::String>,
2151 ///Assign the request to a custom stats group.
2152 #[serde(
2153 rename = "_group",
2154 default,
2155 skip_serializing_if = "::std::option::Option::is_none"
2156 )]
2157 pub group: ::std::option::Option<::std::string::String>,
2158 ///Optional command options encoded as a JSON string.
2159 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2160 pub opt: ::std::option::Option<::std::string::String>,
2161 ///Controls how output is returned; accepts `COMBINED_OUTPUT`,
2162 /// `STREAM`, `STREAM_ONLY_STDOUT`, or `STREAM_ONLY_STDERR`.
2163 #[serde(
2164 rename = "returnType",
2165 default,
2166 skip_serializing_if = "::std::option::Option::is_none"
2167 )]
2168 pub return_type: ::std::option::Option<::std::string::String>,
2169 }
2170
2171 impl ::std::convert::From<&CoreCommandRequest> for CoreCommandRequest {
2172 fn from(value: &CoreCommandRequest) -> Self {
2173 value.clone()
2174 }
2175 }
2176
2177 impl ::std::default::Default for CoreCommandRequest {
2178 fn default() -> Self {
2179 Self {
2180 arg: Default::default(),
2181 async_: Default::default(),
2182 command: Default::default(),
2183 group: Default::default(),
2184 opt: Default::default(),
2185 return_type: Default::default(),
2186 }
2187 }
2188 }
2189
2190 ///`CoreCommandResponse`
2191 ///
2192 /// <details><summary>JSON schema</summary>
2193 ///
2194 /// ```json
2195 ///{
2196 /// "type": "object",
2197 /// "required": [
2198 /// "error"
2199 /// ],
2200 /// "properties": {
2201 /// "error": {
2202 /// "type": "boolean"
2203 /// },
2204 /// "result": {
2205 /// "type": [
2206 /// "string",
2207 /// "null"
2208 /// ]
2209 /// },
2210 /// "returnType": {
2211 /// "type": [
2212 /// "string",
2213 /// "null"
2214 /// ]
2215 /// }
2216 /// }
2217 ///}
2218 /// ```
2219 /// </details>
2220 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2221 pub struct CoreCommandResponse {
2222 pub error: bool,
2223 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2224 pub result: ::std::option::Option<::std::string::String>,
2225 #[serde(
2226 rename = "returnType",
2227 default,
2228 skip_serializing_if = "::std::option::Option::is_none"
2229 )]
2230 pub return_type: ::std::option::Option<::std::string::String>,
2231 }
2232
2233 impl ::std::convert::From<&CoreCommandResponse> for CoreCommandResponse {
2234 fn from(value: &CoreCommandResponse) -> Self {
2235 value.clone()
2236 }
2237 }
2238
2239 ///`CoreDisksRequest`
2240 ///
2241 /// <details><summary>JSON schema</summary>
2242 ///
2243 /// ```json
2244 ///{
2245 /// "type": "object",
2246 /// "properties": {
2247 /// "_async": {
2248 /// "description": "Run the command asynchronously. Returns a job id
2249 /// immediately.",
2250 /// "type": "boolean"
2251 /// },
2252 /// "_group": {
2253 /// "description": "Assign the request to a custom stats group.",
2254 /// "type": "string"
2255 /// }
2256 /// }
2257 ///}
2258 /// ```
2259 /// </details>
2260 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2261 pub struct CoreDisksRequest {
2262 ///Run the command asynchronously. Returns a job id immediately.
2263 #[serde(
2264 rename = "_async",
2265 default,
2266 skip_serializing_if = "::std::option::Option::is_none"
2267 )]
2268 pub async_: ::std::option::Option<bool>,
2269 ///Assign the request to a custom stats group.
2270 #[serde(
2271 rename = "_group",
2272 default,
2273 skip_serializing_if = "::std::option::Option::is_none"
2274 )]
2275 pub group: ::std::option::Option<::std::string::String>,
2276 }
2277
2278 impl ::std::convert::From<&CoreDisksRequest> for CoreDisksRequest {
2279 fn from(value: &CoreDisksRequest) -> Self {
2280 value.clone()
2281 }
2282 }
2283
2284 impl ::std::default::Default for CoreDisksRequest {
2285 fn default() -> Self {
2286 Self {
2287 async_: Default::default(),
2288 group: Default::default(),
2289 }
2290 }
2291 }
2292
2293 ///`CoreDisksResponse`
2294 ///
2295 /// <details><summary>JSON schema</summary>
2296 ///
2297 /// ```json
2298 ///{
2299 /// "type": "object",
2300 /// "required": [
2301 /// "disks"
2302 /// ],
2303 /// "properties": {
2304 /// "disks": {
2305 /// "description": "Accessible local paths such as disk mount points,
2306 /// user home folders, and removable volumes.",
2307 /// "type": "array",
2308 /// "items": {
2309 /// "type": "string"
2310 /// }
2311 /// }
2312 /// }
2313 ///}
2314 /// ```
2315 /// </details>
2316 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2317 pub struct CoreDisksResponse {
2318 ///Accessible local paths such as disk mount points, user home folders,
2319 /// and removable volumes.
2320 pub disks: ::std::vec::Vec<::std::string::String>,
2321 }
2322
2323 impl ::std::convert::From<&CoreDisksResponse> for CoreDisksResponse {
2324 fn from(value: &CoreDisksResponse) -> Self {
2325 value.clone()
2326 }
2327 }
2328
2329 ///`CoreDuRequest`
2330 ///
2331 /// <details><summary>JSON schema</summary>
2332 ///
2333 /// ```json
2334 ///{
2335 /// "type": "object",
2336 /// "properties": {
2337 /// "_async": {
2338 /// "description": "Run the command asynchronously. Returns a job id
2339 /// immediately.",
2340 /// "type": "boolean"
2341 /// },
2342 /// "_group": {
2343 /// "description": "Assign the request to a custom stats group.",
2344 /// "type": "string"
2345 /// },
2346 /// "dir": {
2347 /// "description": "Local directory path to report disk usage for.
2348 /// Defaults to the rclone cache directory when omitted.",
2349 /// "type": "string"
2350 /// }
2351 /// }
2352 ///}
2353 /// ```
2354 /// </details>
2355 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2356 pub struct CoreDuRequest {
2357 ///Run the command asynchronously. Returns a job id immediately.
2358 #[serde(
2359 rename = "_async",
2360 default,
2361 skip_serializing_if = "::std::option::Option::is_none"
2362 )]
2363 pub async_: ::std::option::Option<bool>,
2364 ///Local directory path to report disk usage for. Defaults to the
2365 /// rclone cache directory when omitted.
2366 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2367 pub dir: ::std::option::Option<::std::string::String>,
2368 ///Assign the request to a custom stats group.
2369 #[serde(
2370 rename = "_group",
2371 default,
2372 skip_serializing_if = "::std::option::Option::is_none"
2373 )]
2374 pub group: ::std::option::Option<::std::string::String>,
2375 }
2376
2377 impl ::std::convert::From<&CoreDuRequest> for CoreDuRequest {
2378 fn from(value: &CoreDuRequest) -> Self {
2379 value.clone()
2380 }
2381 }
2382
2383 impl ::std::default::Default for CoreDuRequest {
2384 fn default() -> Self {
2385 Self {
2386 async_: Default::default(),
2387 dir: Default::default(),
2388 group: Default::default(),
2389 }
2390 }
2391 }
2392
2393 ///`CoreDuResponse`
2394 ///
2395 /// <details><summary>JSON schema</summary>
2396 ///
2397 /// ```json
2398 ///{
2399 /// "type": "object",
2400 /// "required": [
2401 /// "dir",
2402 /// "info"
2403 /// ],
2404 /// "properties": {
2405 /// "dir": {
2406 /// "type": "string"
2407 /// },
2408 /// "info": {
2409 /// "type": "object",
2410 /// "required": [
2411 /// "Available",
2412 /// "Free",
2413 /// "Total"
2414 /// ],
2415 /// "properties": {
2416 /// "Available": {
2417 /// "type": "integer"
2418 /// },
2419 /// "Free": {
2420 /// "type": "integer"
2421 /// },
2422 /// "Total": {
2423 /// "type": "integer"
2424 /// }
2425 /// }
2426 /// }
2427 /// }
2428 ///}
2429 /// ```
2430 /// </details>
2431 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2432 pub struct CoreDuResponse {
2433 pub dir: ::std::string::String,
2434 pub info: CoreDuResponseInfo,
2435 }
2436
2437 impl ::std::convert::From<&CoreDuResponse> for CoreDuResponse {
2438 fn from(value: &CoreDuResponse) -> Self {
2439 value.clone()
2440 }
2441 }
2442
2443 ///`CoreDuResponseInfo`
2444 ///
2445 /// <details><summary>JSON schema</summary>
2446 ///
2447 /// ```json
2448 ///{
2449 /// "type": "object",
2450 /// "required": [
2451 /// "Available",
2452 /// "Free",
2453 /// "Total"
2454 /// ],
2455 /// "properties": {
2456 /// "Available": {
2457 /// "type": "integer"
2458 /// },
2459 /// "Free": {
2460 /// "type": "integer"
2461 /// },
2462 /// "Total": {
2463 /// "type": "integer"
2464 /// }
2465 /// }
2466 ///}
2467 /// ```
2468 /// </details>
2469 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2470 pub struct CoreDuResponseInfo {
2471 #[serde(rename = "Available")]
2472 pub available: i64,
2473 #[serde(rename = "Free")]
2474 pub free: i64,
2475 #[serde(rename = "Total")]
2476 pub total: i64,
2477 }
2478
2479 impl ::std::convert::From<&CoreDuResponseInfo> for CoreDuResponseInfo {
2480 fn from(value: &CoreDuResponseInfo) -> Self {
2481 value.clone()
2482 }
2483 }
2484
2485 ///`CoreGcRequest`
2486 ///
2487 /// <details><summary>JSON schema</summary>
2488 ///
2489 /// ```json
2490 ///{
2491 /// "type": "object",
2492 /// "properties": {
2493 /// "_async": {
2494 /// "description": "Run the command asynchronously. Returns a job id
2495 /// immediately.",
2496 /// "type": "boolean"
2497 /// },
2498 /// "_group": {
2499 /// "description": "Assign the request to a custom stats group.",
2500 /// "type": "string"
2501 /// }
2502 /// }
2503 ///}
2504 /// ```
2505 /// </details>
2506 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2507 pub struct CoreGcRequest {
2508 ///Run the command asynchronously. Returns a job id immediately.
2509 #[serde(
2510 rename = "_async",
2511 default,
2512 skip_serializing_if = "::std::option::Option::is_none"
2513 )]
2514 pub async_: ::std::option::Option<bool>,
2515 ///Assign the request to a custom stats group.
2516 #[serde(
2517 rename = "_group",
2518 default,
2519 skip_serializing_if = "::std::option::Option::is_none"
2520 )]
2521 pub group: ::std::option::Option<::std::string::String>,
2522 }
2523
2524 impl ::std::convert::From<&CoreGcRequest> for CoreGcRequest {
2525 fn from(value: &CoreGcRequest) -> Self {
2526 value.clone()
2527 }
2528 }
2529
2530 impl ::std::default::Default for CoreGcRequest {
2531 fn default() -> Self {
2532 Self {
2533 async_: Default::default(),
2534 group: Default::default(),
2535 }
2536 }
2537 }
2538
2539 ///`CoreGcResponse`
2540 ///
2541 /// <details><summary>JSON schema</summary>
2542 ///
2543 /// ```json
2544 ///{
2545 /// "type": "object",
2546 /// "properties": {
2547 /// "jobid": {
2548 /// "description": "Job ID returned when _async=true.",
2549 /// "type": "integer"
2550 /// }
2551 /// },
2552 /// "additionalProperties": true
2553 ///}
2554 /// ```
2555 /// </details>
2556 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2557 pub struct CoreGcResponse {
2558 ///Job ID returned when _async=true.
2559 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2560 pub jobid: ::std::option::Option<i64>,
2561 }
2562
2563 impl ::std::convert::From<&CoreGcResponse> for CoreGcResponse {
2564 fn from(value: &CoreGcResponse) -> Self {
2565 value.clone()
2566 }
2567 }
2568
2569 impl ::std::default::Default for CoreGcResponse {
2570 fn default() -> Self {
2571 Self {
2572 jobid: Default::default(),
2573 }
2574 }
2575 }
2576
2577 ///`CoreGroupListRequest`
2578 ///
2579 /// <details><summary>JSON schema</summary>
2580 ///
2581 /// ```json
2582 ///{
2583 /// "type": "object",
2584 /// "properties": {
2585 /// "_async": {
2586 /// "description": "Run the command asynchronously. Returns a job id
2587 /// immediately.",
2588 /// "type": "boolean"
2589 /// },
2590 /// "_group": {
2591 /// "description": "Assign the request to a custom stats group.",
2592 /// "type": "string"
2593 /// }
2594 /// }
2595 ///}
2596 /// ```
2597 /// </details>
2598 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2599 pub struct CoreGroupListRequest {
2600 ///Run the command asynchronously. Returns a job id immediately.
2601 #[serde(
2602 rename = "_async",
2603 default,
2604 skip_serializing_if = "::std::option::Option::is_none"
2605 )]
2606 pub async_: ::std::option::Option<bool>,
2607 ///Assign the request to a custom stats group.
2608 #[serde(
2609 rename = "_group",
2610 default,
2611 skip_serializing_if = "::std::option::Option::is_none"
2612 )]
2613 pub group: ::std::option::Option<::std::string::String>,
2614 }
2615
2616 impl ::std::convert::From<&CoreGroupListRequest> for CoreGroupListRequest {
2617 fn from(value: &CoreGroupListRequest) -> Self {
2618 value.clone()
2619 }
2620 }
2621
2622 impl ::std::default::Default for CoreGroupListRequest {
2623 fn default() -> Self {
2624 Self {
2625 async_: Default::default(),
2626 group: Default::default(),
2627 }
2628 }
2629 }
2630
2631 ///`CoreGroupListResponse`
2632 ///
2633 /// <details><summary>JSON schema</summary>
2634 ///
2635 /// ```json
2636 ///{
2637 /// "type": "object",
2638 /// "required": [
2639 /// "groups"
2640 /// ],
2641 /// "properties": {
2642 /// "groups": {
2643 /// "type": "array",
2644 /// "items": {
2645 /// "type": "string"
2646 /// }
2647 /// }
2648 /// }
2649 ///}
2650 /// ```
2651 /// </details>
2652 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2653 pub struct CoreGroupListResponse {
2654 pub groups: ::std::vec::Vec<::std::string::String>,
2655 }
2656
2657 impl ::std::convert::From<&CoreGroupListResponse> for CoreGroupListResponse {
2658 fn from(value: &CoreGroupListResponse) -> Self {
2659 value.clone()
2660 }
2661 }
2662
2663 ///`CoreMemstatsRequest`
2664 ///
2665 /// <details><summary>JSON schema</summary>
2666 ///
2667 /// ```json
2668 ///{
2669 /// "type": "object",
2670 /// "properties": {
2671 /// "_async": {
2672 /// "description": "Run the command asynchronously. Returns a job id
2673 /// immediately.",
2674 /// "type": "boolean"
2675 /// },
2676 /// "_group": {
2677 /// "description": "Assign the request to a custom stats group.",
2678 /// "type": "string"
2679 /// }
2680 /// }
2681 ///}
2682 /// ```
2683 /// </details>
2684 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2685 pub struct CoreMemstatsRequest {
2686 ///Run the command asynchronously. Returns a job id immediately.
2687 #[serde(
2688 rename = "_async",
2689 default,
2690 skip_serializing_if = "::std::option::Option::is_none"
2691 )]
2692 pub async_: ::std::option::Option<bool>,
2693 ///Assign the request to a custom stats group.
2694 #[serde(
2695 rename = "_group",
2696 default,
2697 skip_serializing_if = "::std::option::Option::is_none"
2698 )]
2699 pub group: ::std::option::Option<::std::string::String>,
2700 }
2701
2702 impl ::std::convert::From<&CoreMemstatsRequest> for CoreMemstatsRequest {
2703 fn from(value: &CoreMemstatsRequest) -> Self {
2704 value.clone()
2705 }
2706 }
2707
2708 impl ::std::default::Default for CoreMemstatsRequest {
2709 fn default() -> Self {
2710 Self {
2711 async_: Default::default(),
2712 group: Default::default(),
2713 }
2714 }
2715 }
2716
2717 ///`CoreObscureRequest`
2718 ///
2719 /// <details><summary>JSON schema</summary>
2720 ///
2721 /// ```json
2722 ///{
2723 /// "type": "object",
2724 /// "properties": {
2725 /// "_async": {
2726 /// "description": "Run the command asynchronously. Returns a job id
2727 /// immediately.",
2728 /// "type": "boolean"
2729 /// },
2730 /// "_group": {
2731 /// "description": "Assign the request to a custom stats group.",
2732 /// "type": "string"
2733 /// },
2734 /// "clear": {
2735 /// "description": "Plain-text string to obscure for storage in the
2736 /// config file.",
2737 /// "type": "string"
2738 /// }
2739 /// }
2740 ///}
2741 /// ```
2742 /// </details>
2743 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2744 pub struct CoreObscureRequest {
2745 ///Run the command asynchronously. Returns a job id immediately.
2746 #[serde(
2747 rename = "_async",
2748 default,
2749 skip_serializing_if = "::std::option::Option::is_none"
2750 )]
2751 pub async_: ::std::option::Option<bool>,
2752 ///Plain-text string to obscure for storage in the config file.
2753 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2754 pub clear: ::std::option::Option<::std::string::String>,
2755 ///Assign the request to a custom stats group.
2756 #[serde(
2757 rename = "_group",
2758 default,
2759 skip_serializing_if = "::std::option::Option::is_none"
2760 )]
2761 pub group: ::std::option::Option<::std::string::String>,
2762 }
2763
2764 impl ::std::convert::From<&CoreObscureRequest> for CoreObscureRequest {
2765 fn from(value: &CoreObscureRequest) -> Self {
2766 value.clone()
2767 }
2768 }
2769
2770 impl ::std::default::Default for CoreObscureRequest {
2771 fn default() -> Self {
2772 Self {
2773 async_: Default::default(),
2774 clear: Default::default(),
2775 group: Default::default(),
2776 }
2777 }
2778 }
2779
2780 ///`CoreObscureResponse`
2781 ///
2782 /// <details><summary>JSON schema</summary>
2783 ///
2784 /// ```json
2785 ///{
2786 /// "type": "object",
2787 /// "required": [
2788 /// "obscured"
2789 /// ],
2790 /// "properties": {
2791 /// "obscured": {
2792 /// "type": "string"
2793 /// }
2794 /// }
2795 ///}
2796 /// ```
2797 /// </details>
2798 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2799 pub struct CoreObscureResponse {
2800 pub obscured: ::std::string::String,
2801 }
2802
2803 impl ::std::convert::From<&CoreObscureResponse> for CoreObscureResponse {
2804 fn from(value: &CoreObscureResponse) -> Self {
2805 value.clone()
2806 }
2807 }
2808
2809 ///`CorePidRequest`
2810 ///
2811 /// <details><summary>JSON schema</summary>
2812 ///
2813 /// ```json
2814 ///{
2815 /// "type": "object",
2816 /// "properties": {
2817 /// "_async": {
2818 /// "description": "Run the command asynchronously. Returns a job id
2819 /// immediately.",
2820 /// "type": "boolean"
2821 /// },
2822 /// "_group": {
2823 /// "description": "Assign the request to a custom stats group.",
2824 /// "type": "string"
2825 /// }
2826 /// }
2827 ///}
2828 /// ```
2829 /// </details>
2830 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2831 pub struct CorePidRequest {
2832 ///Run the command asynchronously. Returns a job id immediately.
2833 #[serde(
2834 rename = "_async",
2835 default,
2836 skip_serializing_if = "::std::option::Option::is_none"
2837 )]
2838 pub async_: ::std::option::Option<bool>,
2839 ///Assign the request to a custom stats group.
2840 #[serde(
2841 rename = "_group",
2842 default,
2843 skip_serializing_if = "::std::option::Option::is_none"
2844 )]
2845 pub group: ::std::option::Option<::std::string::String>,
2846 }
2847
2848 impl ::std::convert::From<&CorePidRequest> for CorePidRequest {
2849 fn from(value: &CorePidRequest) -> Self {
2850 value.clone()
2851 }
2852 }
2853
2854 impl ::std::default::Default for CorePidRequest {
2855 fn default() -> Self {
2856 Self {
2857 async_: Default::default(),
2858 group: Default::default(),
2859 }
2860 }
2861 }
2862
2863 ///`CorePidResponse`
2864 ///
2865 /// <details><summary>JSON schema</summary>
2866 ///
2867 /// ```json
2868 ///{
2869 /// "type": "object",
2870 /// "required": [
2871 /// "pid"
2872 /// ],
2873 /// "properties": {
2874 /// "pid": {
2875 /// "type": "integer"
2876 /// }
2877 /// }
2878 ///}
2879 /// ```
2880 /// </details>
2881 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2882 pub struct CorePidResponse {
2883 pub pid: i64,
2884 }
2885
2886 impl ::std::convert::From<&CorePidResponse> for CorePidResponse {
2887 fn from(value: &CorePidResponse) -> Self {
2888 value.clone()
2889 }
2890 }
2891
2892 ///`CoreQuitRequest`
2893 ///
2894 /// <details><summary>JSON schema</summary>
2895 ///
2896 /// ```json
2897 ///{
2898 /// "type": "object",
2899 /// "properties": {
2900 /// "_async": {
2901 /// "description": "Run the command asynchronously. Returns a job id
2902 /// immediately.",
2903 /// "type": "boolean"
2904 /// },
2905 /// "_group": {
2906 /// "description": "Assign the request to a custom stats group.",
2907 /// "type": "string"
2908 /// },
2909 /// "exitCode": {
2910 /// "description": "Optional exit code to use when terminating the
2911 /// rclone process.",
2912 /// "type": "integer"
2913 /// }
2914 /// }
2915 ///}
2916 /// ```
2917 /// </details>
2918 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2919 pub struct CoreQuitRequest {
2920 ///Run the command asynchronously. Returns a job id immediately.
2921 #[serde(
2922 rename = "_async",
2923 default,
2924 skip_serializing_if = "::std::option::Option::is_none"
2925 )]
2926 pub async_: ::std::option::Option<bool>,
2927 ///Optional exit code to use when terminating the rclone process.
2928 #[serde(
2929 rename = "exitCode",
2930 default,
2931 skip_serializing_if = "::std::option::Option::is_none"
2932 )]
2933 pub exit_code: ::std::option::Option<i64>,
2934 ///Assign the request to a custom stats group.
2935 #[serde(
2936 rename = "_group",
2937 default,
2938 skip_serializing_if = "::std::option::Option::is_none"
2939 )]
2940 pub group: ::std::option::Option<::std::string::String>,
2941 }
2942
2943 impl ::std::convert::From<&CoreQuitRequest> for CoreQuitRequest {
2944 fn from(value: &CoreQuitRequest) -> Self {
2945 value.clone()
2946 }
2947 }
2948
2949 impl ::std::default::Default for CoreQuitRequest {
2950 fn default() -> Self {
2951 Self {
2952 async_: Default::default(),
2953 exit_code: Default::default(),
2954 group: Default::default(),
2955 }
2956 }
2957 }
2958
2959 ///`CoreQuitResponse`
2960 ///
2961 /// <details><summary>JSON schema</summary>
2962 ///
2963 /// ```json
2964 ///{
2965 /// "type": "object",
2966 /// "properties": {
2967 /// "jobid": {
2968 /// "description": "Job ID returned when _async=true.",
2969 /// "type": "integer"
2970 /// }
2971 /// },
2972 /// "additionalProperties": true
2973 ///}
2974 /// ```
2975 /// </details>
2976 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2977 pub struct CoreQuitResponse {
2978 ///Job ID returned when _async=true.
2979 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2980 pub jobid: ::std::option::Option<i64>,
2981 }
2982
2983 impl ::std::convert::From<&CoreQuitResponse> for CoreQuitResponse {
2984 fn from(value: &CoreQuitResponse) -> Self {
2985 value.clone()
2986 }
2987 }
2988
2989 impl ::std::default::Default for CoreQuitResponse {
2990 fn default() -> Self {
2991 Self {
2992 jobid: Default::default(),
2993 }
2994 }
2995 }
2996
2997 ///Metadata for an item currently undergoing verification.
2998 ///
2999 /// <details><summary>JSON schema</summary>
3000 ///
3001 /// ```json
3002 ///{
3003 /// "description": "Metadata for an item currently undergoing
3004 /// verification.",
3005 /// "type": "object",
3006 /// "properties": {
3007 /// "group": {
3008 /// "description": "Stats group name associated with this
3009 /// verification.",
3010 /// "type": "string"
3011 /// },
3012 /// "name": {
3013 /// "description": "Remote path of the object being verified.",
3014 /// "type": "string"
3015 /// },
3016 /// "size": {
3017 /// "description": "Total size in bytes of the object.",
3018 /// "type": "number"
3019 /// }
3020 /// },
3021 /// "additionalProperties": true
3022 ///}
3023 /// ```
3024 /// </details>
3025 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3026 pub struct CoreStatsChecking {
3027 ///Stats group name associated with this verification.
3028 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3029 pub group: ::std::option::Option<::std::string::String>,
3030 ///Remote path of the object being verified.
3031 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3032 pub name: ::std::option::Option<::std::string::String>,
3033 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3034 pub size: ::std::option::Option<f64>,
3035 }
3036
3037 impl ::std::convert::From<&CoreStatsChecking> for CoreStatsChecking {
3038 fn from(value: &CoreStatsChecking) -> Self {
3039 value.clone()
3040 }
3041 }
3042
3043 impl ::std::default::Default for CoreStatsChecking {
3044 fn default() -> Self {
3045 Self {
3046 group: Default::default(),
3047 name: Default::default(),
3048 size: Default::default(),
3049 }
3050 }
3051 }
3052
3053 ///`CoreStatsDeleteRequest`
3054 ///
3055 /// <details><summary>JSON schema</summary>
3056 ///
3057 /// ```json
3058 ///{
3059 /// "type": "object",
3060 /// "properties": {
3061 /// "_async": {
3062 /// "description": "Run the command asynchronously. Returns a job id
3063 /// immediately.",
3064 /// "type": "boolean"
3065 /// },
3066 /// "_group": {
3067 /// "description": "Assign the request to a custom stats group.",
3068 /// "type": "string"
3069 /// },
3070 /// "group": {
3071 /// "description": "Stats group identifier to remove.",
3072 /// "type": "string"
3073 /// }
3074 /// }
3075 ///}
3076 /// ```
3077 /// </details>
3078 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3079 pub struct CoreStatsDeleteRequest {
3080 ///Run the command asynchronously. Returns a job id immediately.
3081 #[serde(
3082 rename = "_async",
3083 default,
3084 skip_serializing_if = "::std::option::Option::is_none"
3085 )]
3086 pub async_: ::std::option::Option<bool>,
3087 ///Assign the request to a custom stats group.
3088 #[serde(
3089 rename = "_group",
3090 default,
3091 skip_serializing_if = "::std::option::Option::is_none"
3092 )]
3093 pub group_: ::std::option::Option<::std::string::String>,
3094 ///Stats group identifier to remove.
3095 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3096 pub group: ::std::option::Option<::std::string::String>,
3097 }
3098
3099 impl ::std::convert::From<&CoreStatsDeleteRequest> for CoreStatsDeleteRequest {
3100 fn from(value: &CoreStatsDeleteRequest) -> Self {
3101 value.clone()
3102 }
3103 }
3104
3105 impl ::std::default::Default for CoreStatsDeleteRequest {
3106 fn default() -> Self {
3107 Self {
3108 async_: Default::default(),
3109 group_: Default::default(),
3110 group: Default::default(),
3111 }
3112 }
3113 }
3114
3115 ///`CoreStatsDeleteResponse`
3116 ///
3117 /// <details><summary>JSON schema</summary>
3118 ///
3119 /// ```json
3120 ///{
3121 /// "type": "object",
3122 /// "properties": {
3123 /// "jobid": {
3124 /// "description": "Job ID returned when _async=true.",
3125 /// "type": "integer"
3126 /// }
3127 /// },
3128 /// "additionalProperties": true
3129 ///}
3130 /// ```
3131 /// </details>
3132 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3133 pub struct CoreStatsDeleteResponse {
3134 ///Job ID returned when _async=true.
3135 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3136 pub jobid: ::std::option::Option<i64>,
3137 }
3138
3139 impl ::std::convert::From<&CoreStatsDeleteResponse> for CoreStatsDeleteResponse {
3140 fn from(value: &CoreStatsDeleteResponse) -> Self {
3141 value.clone()
3142 }
3143 }
3144
3145 impl ::std::default::Default for CoreStatsDeleteResponse {
3146 fn default() -> Self {
3147 Self {
3148 jobid: Default::default(),
3149 }
3150 }
3151 }
3152
3153 ///`CoreStatsRequest`
3154 ///
3155 /// <details><summary>JSON schema</summary>
3156 ///
3157 /// ```json
3158 ///{
3159 /// "type": "object",
3160 /// "properties": {
3161 /// "_async": {
3162 /// "description": "Run the command asynchronously. Returns a job id
3163 /// immediately.",
3164 /// "type": "boolean"
3165 /// },
3166 /// "_group": {
3167 /// "description": "Assign the request to a custom stats group.",
3168 /// "type": "string"
3169 /// },
3170 /// "group": {
3171 /// "description": "Stats group identifier to return a snapshot for.
3172 /// Leave unset to include all groups.",
3173 /// "type": "string"
3174 /// },
3175 /// "short": {
3176 /// "description": "When true, omit the `transferring` and `checking`
3177 /// arrays from the response.",
3178 /// "type": "boolean"
3179 /// }
3180 /// }
3181 ///}
3182 /// ```
3183 /// </details>
3184 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3185 pub struct CoreStatsRequest {
3186 ///Run the command asynchronously. Returns a job id immediately.
3187 #[serde(
3188 rename = "_async",
3189 default,
3190 skip_serializing_if = "::std::option::Option::is_none"
3191 )]
3192 pub async_: ::std::option::Option<bool>,
3193 ///Assign the request to a custom stats group.
3194 #[serde(
3195 rename = "_group",
3196 default,
3197 skip_serializing_if = "::std::option::Option::is_none"
3198 )]
3199 pub group_: ::std::option::Option<::std::string::String>,
3200 ///Stats group identifier to return a snapshot for. Leave unset to
3201 /// include all groups.
3202 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3203 pub group: ::std::option::Option<::std::string::String>,
3204 ///When true, omit the `transferring` and `checking` arrays from the
3205 /// response.
3206 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3207 pub short: ::std::option::Option<bool>,
3208 }
3209
3210 impl ::std::convert::From<&CoreStatsRequest> for CoreStatsRequest {
3211 fn from(value: &CoreStatsRequest) -> Self {
3212 value.clone()
3213 }
3214 }
3215
3216 impl ::std::default::Default for CoreStatsRequest {
3217 fn default() -> Self {
3218 Self {
3219 async_: Default::default(),
3220 group_: Default::default(),
3221 group: Default::default(),
3222 short: Default::default(),
3223 }
3224 }
3225 }
3226
3227 ///`CoreStatsResetRequest`
3228 ///
3229 /// <details><summary>JSON schema</summary>
3230 ///
3231 /// ```json
3232 ///{
3233 /// "type": "object",
3234 /// "properties": {
3235 /// "_async": {
3236 /// "description": "Run the command asynchronously. Returns a job id
3237 /// immediately.",
3238 /// "type": "boolean"
3239 /// },
3240 /// "_group": {
3241 /// "description": "Assign the request to a custom stats group.",
3242 /// "type": "string"
3243 /// },
3244 /// "group": {
3245 /// "description": "Stats group identifier whose counters should be
3246 /// reset. Leave unset to reset all groups.",
3247 /// "type": "string"
3248 /// }
3249 /// }
3250 ///}
3251 /// ```
3252 /// </details>
3253 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3254 pub struct CoreStatsResetRequest {
3255 ///Run the command asynchronously. Returns a job id immediately.
3256 #[serde(
3257 rename = "_async",
3258 default,
3259 skip_serializing_if = "::std::option::Option::is_none"
3260 )]
3261 pub async_: ::std::option::Option<bool>,
3262 ///Assign the request to a custom stats group.
3263 #[serde(
3264 rename = "_group",
3265 default,
3266 skip_serializing_if = "::std::option::Option::is_none"
3267 )]
3268 pub group_: ::std::option::Option<::std::string::String>,
3269 ///Stats group identifier whose counters should be reset. Leave unset
3270 /// to reset all groups.
3271 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3272 pub group: ::std::option::Option<::std::string::String>,
3273 }
3274
3275 impl ::std::convert::From<&CoreStatsResetRequest> for CoreStatsResetRequest {
3276 fn from(value: &CoreStatsResetRequest) -> Self {
3277 value.clone()
3278 }
3279 }
3280
3281 impl ::std::default::Default for CoreStatsResetRequest {
3282 fn default() -> Self {
3283 Self {
3284 async_: Default::default(),
3285 group_: Default::default(),
3286 group: Default::default(),
3287 }
3288 }
3289 }
3290
3291 ///`CoreStatsResetResponse`
3292 ///
3293 /// <details><summary>JSON schema</summary>
3294 ///
3295 /// ```json
3296 ///{
3297 /// "type": "object",
3298 /// "properties": {
3299 /// "jobid": {
3300 /// "description": "Job ID returned when _async=true.",
3301 /// "type": "integer"
3302 /// }
3303 /// },
3304 /// "additionalProperties": true
3305 ///}
3306 /// ```
3307 /// </details>
3308 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3309 pub struct CoreStatsResetResponse {
3310 ///Job ID returned when _async=true.
3311 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3312 pub jobid: ::std::option::Option<i64>,
3313 }
3314
3315 impl ::std::convert::From<&CoreStatsResetResponse> for CoreStatsResetResponse {
3316 fn from(value: &CoreStatsResetResponse) -> Self {
3317 value.clone()
3318 }
3319 }
3320
3321 impl ::std::default::Default for CoreStatsResetResponse {
3322 fn default() -> Self {
3323 Self {
3324 jobid: Default::default(),
3325 }
3326 }
3327 }
3328
3329 ///`CoreStatsResponse`
3330 ///
3331 /// <details><summary>JSON schema</summary>
3332 ///
3333 /// ```json
3334 ///{
3335 /// "type": "object",
3336 /// "required": [
3337 /// "bytes",
3338 /// "checks",
3339 /// "deletedDirs",
3340 /// "deletes",
3341 /// "elapsedTime",
3342 /// "errors",
3343 /// "fatalError",
3344 /// "renames",
3345 /// "retryError",
3346 /// "serverSideCopies",
3347 /// "serverSideCopyBytes",
3348 /// "serverSideMoveBytes",
3349 /// "serverSideMoves",
3350 /// "speed",
3351 /// "totalBytes",
3352 /// "totalChecks",
3353 /// "totalTransfers",
3354 /// "transferTime",
3355 /// "transfers"
3356 /// ],
3357 /// "properties": {
3358 /// "bytes": {
3359 /// "type": "number"
3360 /// },
3361 /// "checking": {
3362 /// "description": "Objects currently undergoing verification
3363 /// operations.",
3364 /// "type": "array",
3365 /// "items": {
3366 /// "$ref": "#/components/schemas/CoreStatsChecking"
3367 /// }
3368 /// },
3369 /// "checks": {
3370 /// "type": "number"
3371 /// },
3372 /// "deletedDirs": {
3373 /// "type": "number"
3374 /// },
3375 /// "deletes": {
3376 /// "type": "number"
3377 /// },
3378 /// "elapsedTime": {
3379 /// "type": "number"
3380 /// },
3381 /// "errors": {
3382 /// "type": "number"
3383 /// },
3384 /// "eta": {
3385 /// "type": [
3386 /// "number",
3387 /// "null"
3388 /// ]
3389 /// },
3390 /// "fatalError": {
3391 /// "type": "boolean"
3392 /// },
3393 /// "lastError": {
3394 /// "type": "string"
3395 /// },
3396 /// "listed": {
3397 /// "type": "number"
3398 /// },
3399 /// "renames": {
3400 /// "type": "number"
3401 /// },
3402 /// "retryError": {
3403 /// "type": "boolean"
3404 /// },
3405 /// "serverSideCopies": {
3406 /// "type": "number"
3407 /// },
3408 /// "serverSideCopyBytes": {
3409 /// "type": "number"
3410 /// },
3411 /// "serverSideMoveBytes": {
3412 /// "type": "number"
3413 /// },
3414 /// "serverSideMoves": {
3415 /// "type": "number"
3416 /// },
3417 /// "speed": {
3418 /// "type": "number"
3419 /// },
3420 /// "totalBytes": {
3421 /// "type": "number"
3422 /// },
3423 /// "totalChecks": {
3424 /// "type": "number"
3425 /// },
3426 /// "totalTransfers": {
3427 /// "type": "number"
3428 /// },
3429 /// "transferTime": {
3430 /// "type": "number"
3431 /// },
3432 /// "transferring": {
3433 /// "description": "Active transfers currently in progress grouped by
3434 /// stats group.",
3435 /// "type": "array",
3436 /// "items": {
3437 /// "$ref": "#/components/schemas/CoreStatsTransfer"
3438 /// }
3439 /// },
3440 /// "transfers": {
3441 /// "type": "number"
3442 /// }
3443 /// }
3444 ///}
3445 /// ```
3446 /// </details>
3447 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3448 pub struct CoreStatsResponse {
3449 pub bytes: f64,
3450 ///Objects currently undergoing verification operations.
3451 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
3452 pub checking: ::std::vec::Vec<CoreStatsChecking>,
3453 pub checks: f64,
3454 #[serde(rename = "deletedDirs")]
3455 pub deleted_dirs: f64,
3456 pub deletes: f64,
3457 #[serde(rename = "elapsedTime")]
3458 pub elapsed_time: f64,
3459 pub errors: f64,
3460 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3461 pub eta: ::std::option::Option<f64>,
3462 #[serde(rename = "fatalError")]
3463 pub fatal_error: bool,
3464 #[serde(
3465 rename = "lastError",
3466 default,
3467 skip_serializing_if = "::std::option::Option::is_none"
3468 )]
3469 pub last_error: ::std::option::Option<::std::string::String>,
3470 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3471 pub listed: ::std::option::Option<f64>,
3472 pub renames: f64,
3473 #[serde(rename = "retryError")]
3474 pub retry_error: bool,
3475 #[serde(rename = "serverSideCopies")]
3476 pub server_side_copies: f64,
3477 #[serde(rename = "serverSideCopyBytes")]
3478 pub server_side_copy_bytes: f64,
3479 #[serde(rename = "serverSideMoveBytes")]
3480 pub server_side_move_bytes: f64,
3481 #[serde(rename = "serverSideMoves")]
3482 pub server_side_moves: f64,
3483 pub speed: f64,
3484 #[serde(rename = "totalBytes")]
3485 pub total_bytes: f64,
3486 #[serde(rename = "totalChecks")]
3487 pub total_checks: f64,
3488 #[serde(rename = "totalTransfers")]
3489 pub total_transfers: f64,
3490 #[serde(rename = "transferTime")]
3491 pub transfer_time: f64,
3492 ///Active transfers currently in progress grouped by stats group.
3493 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
3494 pub transferring: ::std::vec::Vec<CoreStatsTransfer>,
3495 pub transfers: f64,
3496 }
3497
3498 impl ::std::convert::From<&CoreStatsResponse> for CoreStatsResponse {
3499 fn from(value: &CoreStatsResponse) -> Self {
3500 value.clone()
3501 }
3502 }
3503
3504 ///Progress metrics for an in-flight transfer.
3505 ///
3506 /// <details><summary>JSON schema</summary>
3507 ///
3508 /// ```json
3509 ///{
3510 /// "description": "Progress metrics for an in-flight transfer.",
3511 /// "type": "object",
3512 /// "properties": {
3513 /// "bytes": {
3514 /// "description": "Bytes transferred so far for this object.",
3515 /// "type": "number"
3516 /// },
3517 /// "dstFs": {
3518 /// "description": "Destination remote or filesystem for this
3519 /// transfer.",
3520 /// "type": "string"
3521 /// },
3522 /// "dstRemote": {
3523 /// "description": "Destination path within dstFs.",
3524 /// "type": "string"
3525 /// },
3526 /// "eta": {
3527 /// "description": "Estimated seconds remaining, when available.",
3528 /// "type": [
3529 /// "number",
3530 /// "null"
3531 /// ]
3532 /// },
3533 /// "group": {
3534 /// "description": "Stats group name associated with this transfer.",
3535 /// "type": "string"
3536 /// },
3537 /// "name": {
3538 /// "description": "Remote path of the object being transferred.",
3539 /// "type": "string"
3540 /// },
3541 /// "percentage": {
3542 /// "description": "Completion percentage from 0-100.",
3543 /// "type": "number"
3544 /// },
3545 /// "size": {
3546 /// "description": "Total size in bytes of the object.",
3547 /// "type": "number"
3548 /// },
3549 /// "speed": {
3550 /// "description": "Current transfer speed in bytes per second.",
3551 /// "type": "number"
3552 /// },
3553 /// "speedAvg": {
3554 /// "description": "Current speed in bytes per second as an
3555 /// exponentially weighted moving average.",
3556 /// "type": "number"
3557 /// },
3558 /// "srcFs": {
3559 /// "description": "Source remote or filesystem for this transfer.",
3560 /// "type": "string"
3561 /// },
3562 /// "srcRemote": {
3563 /// "description": "Source path within srcFs.",
3564 /// "type": "string"
3565 /// }
3566 /// },
3567 /// "additionalProperties": true
3568 ///}
3569 /// ```
3570 /// </details>
3571 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3572 pub struct CoreStatsTransfer {
3573 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3574 pub bytes: ::std::option::Option<f64>,
3575 ///Destination remote or filesystem for this transfer.
3576 #[serde(
3577 rename = "dstFs",
3578 default,
3579 skip_serializing_if = "::std::option::Option::is_none"
3580 )]
3581 pub dst_fs: ::std::option::Option<::std::string::String>,
3582 ///Destination path within dstFs.
3583 #[serde(
3584 rename = "dstRemote",
3585 default,
3586 skip_serializing_if = "::std::option::Option::is_none"
3587 )]
3588 pub dst_remote: ::std::option::Option<::std::string::String>,
3589 ///Estimated seconds remaining, when available.
3590 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3591 pub eta: ::std::option::Option<f64>,
3592 ///Stats group name associated with this transfer.
3593 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3594 pub group: ::std::option::Option<::std::string::String>,
3595 ///Remote path of the object being transferred.
3596 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3597 pub name: ::std::option::Option<::std::string::String>,
3598 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3599 pub percentage: ::std::option::Option<f64>,
3600 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3601 pub size: ::std::option::Option<f64>,
3602 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3603 pub speed: ::std::option::Option<f64>,
3604 #[serde(
3605 rename = "speedAvg",
3606 default,
3607 skip_serializing_if = "::std::option::Option::is_none"
3608 )]
3609 pub speed_avg: ::std::option::Option<f64>,
3610 ///Source remote or filesystem for this transfer.
3611 #[serde(
3612 rename = "srcFs",
3613 default,
3614 skip_serializing_if = "::std::option::Option::is_none"
3615 )]
3616 pub src_fs: ::std::option::Option<::std::string::String>,
3617 ///Source path within srcFs.
3618 #[serde(
3619 rename = "srcRemote",
3620 default,
3621 skip_serializing_if = "::std::option::Option::is_none"
3622 )]
3623 pub src_remote: ::std::option::Option<::std::string::String>,
3624 }
3625
3626 impl ::std::convert::From<&CoreStatsTransfer> for CoreStatsTransfer {
3627 fn from(value: &CoreStatsTransfer) -> Self {
3628 value.clone()
3629 }
3630 }
3631
3632 impl ::std::default::Default for CoreStatsTransfer {
3633 fn default() -> Self {
3634 Self {
3635 bytes: Default::default(),
3636 dst_fs: Default::default(),
3637 dst_remote: Default::default(),
3638 eta: Default::default(),
3639 group: Default::default(),
3640 name: Default::default(),
3641 percentage: Default::default(),
3642 size: Default::default(),
3643 speed: Default::default(),
3644 speed_avg: Default::default(),
3645 src_fs: Default::default(),
3646 src_remote: Default::default(),
3647 }
3648 }
3649 }
3650
3651 ///`CoreTransferredRequest`
3652 ///
3653 /// <details><summary>JSON schema</summary>
3654 ///
3655 /// ```json
3656 ///{
3657 /// "type": "object",
3658 /// "properties": {
3659 /// "_async": {
3660 /// "description": "Run the command asynchronously. Returns a job id
3661 /// immediately.",
3662 /// "type": "boolean"
3663 /// },
3664 /// "_group": {
3665 /// "description": "Assign the request to a custom stats group.",
3666 /// "type": "string"
3667 /// },
3668 /// "group": {
3669 /// "description": "Stats group identifier to filter the completed
3670 /// transfer list. Leave unset for all groups.",
3671 /// "type": "string"
3672 /// }
3673 /// }
3674 ///}
3675 /// ```
3676 /// </details>
3677 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3678 pub struct CoreTransferredRequest {
3679 ///Run the command asynchronously. Returns a job id immediately.
3680 #[serde(
3681 rename = "_async",
3682 default,
3683 skip_serializing_if = "::std::option::Option::is_none"
3684 )]
3685 pub async_: ::std::option::Option<bool>,
3686 ///Assign the request to a custom stats group.
3687 #[serde(
3688 rename = "_group",
3689 default,
3690 skip_serializing_if = "::std::option::Option::is_none"
3691 )]
3692 pub group_: ::std::option::Option<::std::string::String>,
3693 ///Stats group identifier to filter the completed transfer list. Leave
3694 /// unset for all groups.
3695 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3696 pub group: ::std::option::Option<::std::string::String>,
3697 }
3698
3699 impl ::std::convert::From<&CoreTransferredRequest> for CoreTransferredRequest {
3700 fn from(value: &CoreTransferredRequest) -> Self {
3701 value.clone()
3702 }
3703 }
3704
3705 impl ::std::default::Default for CoreTransferredRequest {
3706 fn default() -> Self {
3707 Self {
3708 async_: Default::default(),
3709 group_: Default::default(),
3710 group: Default::default(),
3711 }
3712 }
3713 }
3714
3715 ///`CoreTransferredResponse`
3716 ///
3717 /// <details><summary>JSON schema</summary>
3718 ///
3719 /// ```json
3720 ///{
3721 /// "type": "object",
3722 /// "required": [
3723 /// "transferred"
3724 /// ],
3725 /// "properties": {
3726 /// "transferred": {
3727 /// "type": "array",
3728 /// "items": {
3729 /// "type": "object",
3730 /// "required": [
3731 /// "group"
3732 /// ],
3733 /// "properties": {
3734 /// "bytes": {
3735 /// "type": "integer"
3736 /// },
3737 /// "checked": {
3738 /// "type": "boolean"
3739 /// },
3740 /// "completed_at": {
3741 /// "description": "ISO8601 timestamp when the transfer
3742 /// completed.",
3743 /// "type": "string"
3744 /// },
3745 /// "dstFs": {
3746 /// "description": "Destination remote or filesystem used for the
3747 /// transfer.",
3748 /// "type": "string"
3749 /// },
3750 /// "dstRemote": {
3751 /// "description": "Destination path within `dstFs`, when
3752 /// provided.",
3753 /// "type": "string"
3754 /// },
3755 /// "error": {
3756 /// "type": "string"
3757 /// },
3758 /// "group": {
3759 /// "description": "Stats group identifier this transfer belonged
3760 /// to.",
3761 /// "type": "string"
3762 /// },
3763 /// "jobid": {
3764 /// "type": "integer"
3765 /// },
3766 /// "name": {
3767 /// "type": "string"
3768 /// },
3769 /// "size": {
3770 /// "type": "integer"
3771 /// },
3772 /// "srcFs": {
3773 /// "description": "Source remote or filesystem used for the
3774 /// transfer.",
3775 /// "type": "string"
3776 /// },
3777 /// "srcRemote": {
3778 /// "description": "Source path within `srcFs`, when provided.",
3779 /// "type": "string"
3780 /// },
3781 /// "started_at": {
3782 /// "description": "ISO8601 timestamp when the transfer
3783 /// started.",
3784 /// "type": "string"
3785 /// },
3786 /// "timestamp": {
3787 /// "type": "integer"
3788 /// },
3789 /// "what": {
3790 /// "type": "string",
3791 /// "enum": [
3792 /// "transferring",
3793 /// "deleting",
3794 /// "checking",
3795 /// "importing",
3796 /// "hashing",
3797 /// "merging",
3798 /// "listing",
3799 /// "moving",
3800 /// "renaming"
3801 /// ]
3802 /// }
3803 /// },
3804 /// "additionalProperties": true
3805 /// }
3806 /// }
3807 /// }
3808 ///}
3809 /// ```
3810 /// </details>
3811 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3812 pub struct CoreTransferredResponse {
3813 pub transferred: ::std::vec::Vec<CoreTransferredResponseTransferredItem>,
3814 }
3815
3816 impl ::std::convert::From<&CoreTransferredResponse> for CoreTransferredResponse {
3817 fn from(value: &CoreTransferredResponse) -> Self {
3818 value.clone()
3819 }
3820 }
3821
3822 ///`CoreTransferredResponseTransferredItem`
3823 ///
3824 /// <details><summary>JSON schema</summary>
3825 ///
3826 /// ```json
3827 ///{
3828 /// "type": "object",
3829 /// "required": [
3830 /// "group"
3831 /// ],
3832 /// "properties": {
3833 /// "bytes": {
3834 /// "type": "integer"
3835 /// },
3836 /// "checked": {
3837 /// "type": "boolean"
3838 /// },
3839 /// "completed_at": {
3840 /// "description": "ISO8601 timestamp when the transfer completed.",
3841 /// "type": "string"
3842 /// },
3843 /// "dstFs": {
3844 /// "description": "Destination remote or filesystem used for the
3845 /// transfer.",
3846 /// "type": "string"
3847 /// },
3848 /// "dstRemote": {
3849 /// "description": "Destination path within `dstFs`, when provided.",
3850 /// "type": "string"
3851 /// },
3852 /// "error": {
3853 /// "type": "string"
3854 /// },
3855 /// "group": {
3856 /// "description": "Stats group identifier this transfer belonged to.",
3857 /// "type": "string"
3858 /// },
3859 /// "jobid": {
3860 /// "type": "integer"
3861 /// },
3862 /// "name": {
3863 /// "type": "string"
3864 /// },
3865 /// "size": {
3866 /// "type": "integer"
3867 /// },
3868 /// "srcFs": {
3869 /// "description": "Source remote or filesystem used for the
3870 /// transfer.",
3871 /// "type": "string"
3872 /// },
3873 /// "srcRemote": {
3874 /// "description": "Source path within `srcFs`, when provided.",
3875 /// "type": "string"
3876 /// },
3877 /// "started_at": {
3878 /// "description": "ISO8601 timestamp when the transfer started.",
3879 /// "type": "string"
3880 /// },
3881 /// "timestamp": {
3882 /// "type": "integer"
3883 /// },
3884 /// "what": {
3885 /// "type": "string",
3886 /// "enum": [
3887 /// "transferring",
3888 /// "deleting",
3889 /// "checking",
3890 /// "importing",
3891 /// "hashing",
3892 /// "merging",
3893 /// "listing",
3894 /// "moving",
3895 /// "renaming"
3896 /// ]
3897 /// }
3898 /// },
3899 /// "additionalProperties": true
3900 ///}
3901 /// ```
3902 /// </details>
3903 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3904 pub struct CoreTransferredResponseTransferredItem {
3905 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3906 pub bytes: ::std::option::Option<i64>,
3907 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3908 pub checked: ::std::option::Option<bool>,
3909 ///ISO8601 timestamp when the transfer completed.
3910 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3911 pub completed_at: ::std::option::Option<::std::string::String>,
3912 ///Destination remote or filesystem used for the transfer.
3913 #[serde(
3914 rename = "dstFs",
3915 default,
3916 skip_serializing_if = "::std::option::Option::is_none"
3917 )]
3918 pub dst_fs: ::std::option::Option<::std::string::String>,
3919 ///Destination path within `dstFs`, when provided.
3920 #[serde(
3921 rename = "dstRemote",
3922 default,
3923 skip_serializing_if = "::std::option::Option::is_none"
3924 )]
3925 pub dst_remote: ::std::option::Option<::std::string::String>,
3926 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3927 pub error: ::std::option::Option<::std::string::String>,
3928 ///Stats group identifier this transfer belonged to.
3929 pub group: ::std::string::String,
3930 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3931 pub jobid: ::std::option::Option<i64>,
3932 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3933 pub name: ::std::option::Option<::std::string::String>,
3934 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3935 pub size: ::std::option::Option<i64>,
3936 ///Source remote or filesystem used for the transfer.
3937 #[serde(
3938 rename = "srcFs",
3939 default,
3940 skip_serializing_if = "::std::option::Option::is_none"
3941 )]
3942 pub src_fs: ::std::option::Option<::std::string::String>,
3943 ///Source path within `srcFs`, when provided.
3944 #[serde(
3945 rename = "srcRemote",
3946 default,
3947 skip_serializing_if = "::std::option::Option::is_none"
3948 )]
3949 pub src_remote: ::std::option::Option<::std::string::String>,
3950 ///ISO8601 timestamp when the transfer started.
3951 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3952 pub started_at: ::std::option::Option<::std::string::String>,
3953 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3954 pub timestamp: ::std::option::Option<i64>,
3955 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3956 pub what: ::std::option::Option<CoreTransferredResponseTransferredItemWhat>,
3957 }
3958
3959 impl ::std::convert::From<&CoreTransferredResponseTransferredItem>
3960 for CoreTransferredResponseTransferredItem
3961 {
3962 fn from(value: &CoreTransferredResponseTransferredItem) -> Self {
3963 value.clone()
3964 }
3965 }
3966
3967 ///`CoreTransferredResponseTransferredItemWhat`
3968 ///
3969 /// <details><summary>JSON schema</summary>
3970 ///
3971 /// ```json
3972 ///{
3973 /// "type": "string",
3974 /// "enum": [
3975 /// "transferring",
3976 /// "deleting",
3977 /// "checking",
3978 /// "importing",
3979 /// "hashing",
3980 /// "merging",
3981 /// "listing",
3982 /// "moving",
3983 /// "renaming"
3984 /// ]
3985 ///}
3986 /// ```
3987 /// </details>
3988 #[derive(
3989 :: serde :: Deserialize,
3990 :: serde :: Serialize,
3991 Clone,
3992 Copy,
3993 Debug,
3994 Eq,
3995 Hash,
3996 Ord,
3997 PartialEq,
3998 PartialOrd,
3999 )]
4000 pub enum CoreTransferredResponseTransferredItemWhat {
4001 #[serde(rename = "transferring")]
4002 Transferring,
4003 #[serde(rename = "deleting")]
4004 Deleting,
4005 #[serde(rename = "checking")]
4006 Checking,
4007 #[serde(rename = "importing")]
4008 Importing,
4009 #[serde(rename = "hashing")]
4010 Hashing,
4011 #[serde(rename = "merging")]
4012 Merging,
4013 #[serde(rename = "listing")]
4014 Listing,
4015 #[serde(rename = "moving")]
4016 Moving,
4017 #[serde(rename = "renaming")]
4018 Renaming,
4019 }
4020
4021 impl ::std::convert::From<&Self> for CoreTransferredResponseTransferredItemWhat {
4022 fn from(value: &CoreTransferredResponseTransferredItemWhat) -> Self {
4023 value.clone()
4024 }
4025 }
4026
4027 impl ::std::fmt::Display for CoreTransferredResponseTransferredItemWhat {
4028 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4029 match *self {
4030 Self::Transferring => f.write_str("transferring"),
4031 Self::Deleting => f.write_str("deleting"),
4032 Self::Checking => f.write_str("checking"),
4033 Self::Importing => f.write_str("importing"),
4034 Self::Hashing => f.write_str("hashing"),
4035 Self::Merging => f.write_str("merging"),
4036 Self::Listing => f.write_str("listing"),
4037 Self::Moving => f.write_str("moving"),
4038 Self::Renaming => f.write_str("renaming"),
4039 }
4040 }
4041 }
4042
4043 impl ::std::str::FromStr for CoreTransferredResponseTransferredItemWhat {
4044 type Err = self::error::ConversionError;
4045 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4046 match value {
4047 "transferring" => Ok(Self::Transferring),
4048 "deleting" => Ok(Self::Deleting),
4049 "checking" => Ok(Self::Checking),
4050 "importing" => Ok(Self::Importing),
4051 "hashing" => Ok(Self::Hashing),
4052 "merging" => Ok(Self::Merging),
4053 "listing" => Ok(Self::Listing),
4054 "moving" => Ok(Self::Moving),
4055 "renaming" => Ok(Self::Renaming),
4056 _ => Err("invalid value".into()),
4057 }
4058 }
4059 }
4060
4061 impl ::std::convert::TryFrom<&str> for CoreTransferredResponseTransferredItemWhat {
4062 type Error = self::error::ConversionError;
4063 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4064 value.parse()
4065 }
4066 }
4067
4068 impl ::std::convert::TryFrom<&::std::string::String>
4069 for CoreTransferredResponseTransferredItemWhat
4070 {
4071 type Error = self::error::ConversionError;
4072 fn try_from(
4073 value: &::std::string::String,
4074 ) -> ::std::result::Result<Self, self::error::ConversionError> {
4075 value.parse()
4076 }
4077 }
4078
4079 impl ::std::convert::TryFrom<::std::string::String> for CoreTransferredResponseTransferredItemWhat {
4080 type Error = self::error::ConversionError;
4081 fn try_from(
4082 value: ::std::string::String,
4083 ) -> ::std::result::Result<Self, self::error::ConversionError> {
4084 value.parse()
4085 }
4086 }
4087
4088 ///`CoreVersionRequest`
4089 ///
4090 /// <details><summary>JSON schema</summary>
4091 ///
4092 /// ```json
4093 ///{
4094 /// "type": "object",
4095 /// "properties": {
4096 /// "_async": {
4097 /// "description": "Run the command asynchronously. Returns a job id
4098 /// immediately.",
4099 /// "type": "boolean"
4100 /// },
4101 /// "_group": {
4102 /// "description": "Assign the request to a custom stats group.",
4103 /// "type": "string"
4104 /// }
4105 /// }
4106 ///}
4107 /// ```
4108 /// </details>
4109 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4110 pub struct CoreVersionRequest {
4111 ///Run the command asynchronously. Returns a job id immediately.
4112 #[serde(
4113 rename = "_async",
4114 default,
4115 skip_serializing_if = "::std::option::Option::is_none"
4116 )]
4117 pub async_: ::std::option::Option<bool>,
4118 ///Assign the request to a custom stats group.
4119 #[serde(
4120 rename = "_group",
4121 default,
4122 skip_serializing_if = "::std::option::Option::is_none"
4123 )]
4124 pub group: ::std::option::Option<::std::string::String>,
4125 }
4126
4127 impl ::std::convert::From<&CoreVersionRequest> for CoreVersionRequest {
4128 fn from(value: &CoreVersionRequest) -> Self {
4129 value.clone()
4130 }
4131 }
4132
4133 impl ::std::default::Default for CoreVersionRequest {
4134 fn default() -> Self {
4135 Self {
4136 async_: Default::default(),
4137 group: Default::default(),
4138 }
4139 }
4140 }
4141
4142 ///`CoreVersionResponse`
4143 ///
4144 /// <details><summary>JSON schema</summary>
4145 ///
4146 /// ```json
4147 ///{
4148 /// "type": "object",
4149 /// "required": [
4150 /// "arch",
4151 /// "decomposed",
4152 /// "goTags",
4153 /// "goVersion",
4154 /// "isBeta",
4155 /// "isGit",
4156 /// "linking",
4157 /// "os",
4158 /// "version"
4159 /// ],
4160 /// "properties": {
4161 /// "arch": {
4162 /// "description": "CPU architecture (e.g. amd64, arm64).",
4163 /// "type": "string"
4164 /// },
4165 /// "decomposed": {
4166 /// "description": "Version number broken into components.",
4167 /// "type": "array",
4168 /// "items": {
4169 /// "type": "number"
4170 /// }
4171 /// },
4172 /// "goTags": {
4173 /// "description": "Space separated Go build tags, if any.",
4174 /// "type": "string"
4175 /// },
4176 /// "goVersion": {
4177 /// "description": "Go toolchain version used to build rclone.",
4178 /// "type": "string"
4179 /// },
4180 /// "isBeta": {
4181 /// "description": "Indicates whether this build is a beta version.",
4182 /// "type": "boolean"
4183 /// },
4184 /// "isGit": {
4185 /// "description": "True when built directly from a git checkout.",
4186 /// "type": "boolean"
4187 /// },
4188 /// "linking": {
4189 /// "description": "Linking mode for the binary (static or dynamic).",
4190 /// "type": "string"
4191 /// },
4192 /// "os": {
4193 /// "description": "Operating system rclone is running on (e.g. linux,
4194 /// darwin).",
4195 /// "type": "string"
4196 /// },
4197 /// "osArch": {
4198 /// "description": "CPU architecture in use (e.g. arm64 (ARMv8
4199 /// compatible)).",
4200 /// "type": "string"
4201 /// },
4202 /// "osKernel": {
4203 /// "description": "OS Kernel version (e.g. 6.8.0-86-generic
4204 /// (x86_64)).",
4205 /// "type": "string"
4206 /// },
4207 /// "osVersion": {
4208 /// "description": "OS Version (e.g. ubuntu 24.04 (64 bit)).",
4209 /// "type": "string"
4210 /// },
4211 /// "version": {
4212 /// "description": "Full semantic version string (e.g. 1.67.0).",
4213 /// "type": "string"
4214 /// }
4215 /// }
4216 ///}
4217 /// ```
4218 /// </details>
4219 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4220 pub struct CoreVersionResponse {
4221 ///CPU architecture (e.g. amd64, arm64).
4222 pub arch: ::std::string::String,
4223 ///Version number broken into components.
4224 pub decomposed: ::std::vec::Vec<f64>,
4225 ///Space separated Go build tags, if any.
4226 #[serde(rename = "goTags")]
4227 pub go_tags: ::std::string::String,
4228 ///Go toolchain version used to build rclone.
4229 #[serde(rename = "goVersion")]
4230 pub go_version: ::std::string::String,
4231 ///Indicates whether this build is a beta version.
4232 #[serde(rename = "isBeta")]
4233 pub is_beta: bool,
4234 ///True when built directly from a git checkout.
4235 #[serde(rename = "isGit")]
4236 pub is_git: bool,
4237 ///Linking mode for the binary (static or dynamic).
4238 pub linking: ::std::string::String,
4239 ///Operating system rclone is running on (e.g. linux, darwin).
4240 pub os: ::std::string::String,
4241 ///CPU architecture in use (e.g. arm64 (ARMv8 compatible)).
4242 #[serde(
4243 rename = "osArch",
4244 default,
4245 skip_serializing_if = "::std::option::Option::is_none"
4246 )]
4247 pub os_arch: ::std::option::Option<::std::string::String>,
4248 ///OS Kernel version (e.g. 6.8.0-86-generic (x86_64)).
4249 #[serde(
4250 rename = "osKernel",
4251 default,
4252 skip_serializing_if = "::std::option::Option::is_none"
4253 )]
4254 pub os_kernel: ::std::option::Option<::std::string::String>,
4255 ///OS Version (e.g. ubuntu 24.04 (64 bit)).
4256 #[serde(
4257 rename = "osVersion",
4258 default,
4259 skip_serializing_if = "::std::option::Option::is_none"
4260 )]
4261 pub os_version: ::std::option::Option<::std::string::String>,
4262 ///Full semantic version string (e.g. 1.67.0).
4263 pub version: ::std::string::String,
4264 }
4265
4266 impl ::std::convert::From<&CoreVersionResponse> for CoreVersionResponse {
4267 fn from(value: &CoreVersionResponse) -> Self {
4268 value.clone()
4269 }
4270 }
4271
4272 ///`DebugSetBlockProfileRateRequest`
4273 ///
4274 /// <details><summary>JSON schema</summary>
4275 ///
4276 /// ```json
4277 ///{
4278 /// "type": "object",
4279 /// "properties": {
4280 /// "_async": {
4281 /// "description": "Run the command asynchronously. Returns a job id
4282 /// immediately.",
4283 /// "type": "boolean"
4284 /// },
4285 /// "_group": {
4286 /// "description": "Assign the request to a custom stats group.",
4287 /// "type": "string"
4288 /// },
4289 /// "rate": {
4290 /// "description": "Sampling interval in nanoseconds for blocking
4291 /// profile collection; use 1 to capture all events.",
4292 /// "type": "integer"
4293 /// }
4294 /// }
4295 ///}
4296 /// ```
4297 /// </details>
4298 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4299 pub struct DebugSetBlockProfileRateRequest {
4300 ///Run the command asynchronously. Returns a job id immediately.
4301 #[serde(
4302 rename = "_async",
4303 default,
4304 skip_serializing_if = "::std::option::Option::is_none"
4305 )]
4306 pub async_: ::std::option::Option<bool>,
4307 ///Assign the request to a custom stats group.
4308 #[serde(
4309 rename = "_group",
4310 default,
4311 skip_serializing_if = "::std::option::Option::is_none"
4312 )]
4313 pub group: ::std::option::Option<::std::string::String>,
4314 ///Sampling interval in nanoseconds for blocking profile collection;
4315 /// use 1 to capture all events.
4316 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4317 pub rate: ::std::option::Option<i64>,
4318 }
4319
4320 impl ::std::convert::From<&DebugSetBlockProfileRateRequest> for DebugSetBlockProfileRateRequest {
4321 fn from(value: &DebugSetBlockProfileRateRequest) -> Self {
4322 value.clone()
4323 }
4324 }
4325
4326 impl ::std::default::Default for DebugSetBlockProfileRateRequest {
4327 fn default() -> Self {
4328 Self {
4329 async_: Default::default(),
4330 group: Default::default(),
4331 rate: Default::default(),
4332 }
4333 }
4334 }
4335
4336 ///`DebugSetBlockProfileRateResponse`
4337 ///
4338 /// <details><summary>JSON schema</summary>
4339 ///
4340 /// ```json
4341 ///{
4342 /// "type": "object",
4343 /// "properties": {
4344 /// "jobid": {
4345 /// "description": "Job ID returned when _async=true.",
4346 /// "type": "integer"
4347 /// }
4348 /// },
4349 /// "additionalProperties": true
4350 ///}
4351 /// ```
4352 /// </details>
4353 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4354 pub struct DebugSetBlockProfileRateResponse {
4355 ///Job ID returned when _async=true.
4356 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4357 pub jobid: ::std::option::Option<i64>,
4358 }
4359
4360 impl ::std::convert::From<&DebugSetBlockProfileRateResponse> for DebugSetBlockProfileRateResponse {
4361 fn from(value: &DebugSetBlockProfileRateResponse) -> Self {
4362 value.clone()
4363 }
4364 }
4365
4366 impl ::std::default::Default for DebugSetBlockProfileRateResponse {
4367 fn default() -> Self {
4368 Self {
4369 jobid: Default::default(),
4370 }
4371 }
4372 }
4373
4374 ///`DebugSetGcPercentRequest`
4375 ///
4376 /// <details><summary>JSON schema</summary>
4377 ///
4378 /// ```json
4379 ///{
4380 /// "type": "object",
4381 /// "properties": {
4382 /// "_async": {
4383 /// "description": "Run the command asynchronously. Returns a job id
4384 /// immediately.",
4385 /// "type": "boolean"
4386 /// },
4387 /// "_group": {
4388 /// "description": "Assign the request to a custom stats group.",
4389 /// "type": "string"
4390 /// },
4391 /// "gc-percent": {
4392 /// "description": "Target percentage of newly allocated data to
4393 /// trigger garbage collection.",
4394 /// "type": "integer"
4395 /// }
4396 /// }
4397 ///}
4398 /// ```
4399 /// </details>
4400 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4401 pub struct DebugSetGcPercentRequest {
4402 ///Run the command asynchronously. Returns a job id immediately.
4403 #[serde(
4404 rename = "_async",
4405 default,
4406 skip_serializing_if = "::std::option::Option::is_none"
4407 )]
4408 pub async_: ::std::option::Option<bool>,
4409 ///Target percentage of newly allocated data to trigger garbage
4410 /// collection.
4411 #[serde(
4412 rename = "gc-percent",
4413 default,
4414 skip_serializing_if = "::std::option::Option::is_none"
4415 )]
4416 pub gc_percent: ::std::option::Option<i64>,
4417 ///Assign the request to a custom stats group.
4418 #[serde(
4419 rename = "_group",
4420 default,
4421 skip_serializing_if = "::std::option::Option::is_none"
4422 )]
4423 pub group: ::std::option::Option<::std::string::String>,
4424 }
4425
4426 impl ::std::convert::From<&DebugSetGcPercentRequest> for DebugSetGcPercentRequest {
4427 fn from(value: &DebugSetGcPercentRequest) -> Self {
4428 value.clone()
4429 }
4430 }
4431
4432 impl ::std::default::Default for DebugSetGcPercentRequest {
4433 fn default() -> Self {
4434 Self {
4435 async_: Default::default(),
4436 gc_percent: Default::default(),
4437 group: Default::default(),
4438 }
4439 }
4440 }
4441
4442 ///`DebugSetGcPercentResponse`
4443 ///
4444 /// <details><summary>JSON schema</summary>
4445 ///
4446 /// ```json
4447 ///{
4448 /// "type": "object",
4449 /// "required": [
4450 /// "existing-gc-percent"
4451 /// ],
4452 /// "properties": {
4453 /// "existing-gc-percent": {
4454 /// "type": "integer"
4455 /// }
4456 /// }
4457 ///}
4458 /// ```
4459 /// </details>
4460 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4461 pub struct DebugSetGcPercentResponse {
4462 #[serde(rename = "existing-gc-percent")]
4463 pub existing_gc_percent: i64,
4464 }
4465
4466 impl ::std::convert::From<&DebugSetGcPercentResponse> for DebugSetGcPercentResponse {
4467 fn from(value: &DebugSetGcPercentResponse) -> Self {
4468 value.clone()
4469 }
4470 }
4471
4472 ///`DebugSetMutexProfileFractionRequest`
4473 ///
4474 /// <details><summary>JSON schema</summary>
4475 ///
4476 /// ```json
4477 ///{
4478 /// "type": "object",
4479 /// "properties": {
4480 /// "_async": {
4481 /// "description": "Run the command asynchronously. Returns a job id
4482 /// immediately.",
4483 /// "type": "boolean"
4484 /// },
4485 /// "_group": {
4486 /// "description": "Assign the request to a custom stats group.",
4487 /// "type": "string"
4488 /// },
4489 /// "rate": {
4490 /// "description": "Sampling fraction for mutex contention profiling;
4491 /// set to 0 to disable.",
4492 /// "type": "integer"
4493 /// }
4494 /// }
4495 ///}
4496 /// ```
4497 /// </details>
4498 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4499 pub struct DebugSetMutexProfileFractionRequest {
4500 ///Run the command asynchronously. Returns a job id immediately.
4501 #[serde(
4502 rename = "_async",
4503 default,
4504 skip_serializing_if = "::std::option::Option::is_none"
4505 )]
4506 pub async_: ::std::option::Option<bool>,
4507 ///Assign the request to a custom stats group.
4508 #[serde(
4509 rename = "_group",
4510 default,
4511 skip_serializing_if = "::std::option::Option::is_none"
4512 )]
4513 pub group: ::std::option::Option<::std::string::String>,
4514 ///Sampling fraction for mutex contention profiling; set to 0 to
4515 /// disable.
4516 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4517 pub rate: ::std::option::Option<i64>,
4518 }
4519
4520 impl ::std::convert::From<&DebugSetMutexProfileFractionRequest>
4521 for DebugSetMutexProfileFractionRequest
4522 {
4523 fn from(value: &DebugSetMutexProfileFractionRequest) -> Self {
4524 value.clone()
4525 }
4526 }
4527
4528 impl ::std::default::Default for DebugSetMutexProfileFractionRequest {
4529 fn default() -> Self {
4530 Self {
4531 async_: Default::default(),
4532 group: Default::default(),
4533 rate: Default::default(),
4534 }
4535 }
4536 }
4537
4538 ///`DebugSetMutexProfileFractionResponse`
4539 ///
4540 /// <details><summary>JSON schema</summary>
4541 ///
4542 /// ```json
4543 ///{
4544 /// "type": "object",
4545 /// "required": [
4546 /// "previousRate"
4547 /// ],
4548 /// "properties": {
4549 /// "previousRate": {
4550 /// "type": "integer"
4551 /// }
4552 /// }
4553 ///}
4554 /// ```
4555 /// </details>
4556 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4557 pub struct DebugSetMutexProfileFractionResponse {
4558 #[serde(rename = "previousRate")]
4559 pub previous_rate: i64,
4560 }
4561
4562 impl ::std::convert::From<&DebugSetMutexProfileFractionResponse>
4563 for DebugSetMutexProfileFractionResponse
4564 {
4565 fn from(value: &DebugSetMutexProfileFractionResponse) -> Self {
4566 value.clone()
4567 }
4568 }
4569
4570 ///`DebugSetSoftMemoryLimitRequest`
4571 ///
4572 /// <details><summary>JSON schema</summary>
4573 ///
4574 /// ```json
4575 ///{
4576 /// "type": "object",
4577 /// "properties": {
4578 /// "_async": {
4579 /// "description": "Run the command asynchronously. Returns a job id
4580 /// immediately.",
4581 /// "type": "boolean"
4582 /// },
4583 /// "_group": {
4584 /// "description": "Assign the request to a custom stats group.",
4585 /// "type": "string"
4586 /// },
4587 /// "mem-limit": {
4588 /// "description": "Soft memory limit for the Go runtime in bytes.",
4589 /// "type": "integer"
4590 /// }
4591 /// }
4592 ///}
4593 /// ```
4594 /// </details>
4595 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4596 pub struct DebugSetSoftMemoryLimitRequest {
4597 ///Run the command asynchronously. Returns a job id immediately.
4598 #[serde(
4599 rename = "_async",
4600 default,
4601 skip_serializing_if = "::std::option::Option::is_none"
4602 )]
4603 pub async_: ::std::option::Option<bool>,
4604 ///Assign the request to a custom stats group.
4605 #[serde(
4606 rename = "_group",
4607 default,
4608 skip_serializing_if = "::std::option::Option::is_none"
4609 )]
4610 pub group: ::std::option::Option<::std::string::String>,
4611 ///Soft memory limit for the Go runtime in bytes.
4612 #[serde(
4613 rename = "mem-limit",
4614 default,
4615 skip_serializing_if = "::std::option::Option::is_none"
4616 )]
4617 pub mem_limit: ::std::option::Option<i64>,
4618 }
4619
4620 impl ::std::convert::From<&DebugSetSoftMemoryLimitRequest> for DebugSetSoftMemoryLimitRequest {
4621 fn from(value: &DebugSetSoftMemoryLimitRequest) -> Self {
4622 value.clone()
4623 }
4624 }
4625
4626 impl ::std::default::Default for DebugSetSoftMemoryLimitRequest {
4627 fn default() -> Self {
4628 Self {
4629 async_: Default::default(),
4630 group: Default::default(),
4631 mem_limit: Default::default(),
4632 }
4633 }
4634 }
4635
4636 ///`DebugSetSoftMemoryLimitResponse`
4637 ///
4638 /// <details><summary>JSON schema</summary>
4639 ///
4640 /// ```json
4641 ///{
4642 /// "type": "object",
4643 /// "required": [
4644 /// "existing-mem-limit"
4645 /// ],
4646 /// "properties": {
4647 /// "existing-mem-limit": {
4648 /// "type": "integer"
4649 /// }
4650 /// }
4651 ///}
4652 /// ```
4653 /// </details>
4654 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4655 pub struct DebugSetSoftMemoryLimitResponse {
4656 #[serde(rename = "existing-mem-limit")]
4657 pub existing_mem_limit: i64,
4658 }
4659
4660 impl ::std::convert::From<&DebugSetSoftMemoryLimitResponse> for DebugSetSoftMemoryLimitResponse {
4661 fn from(value: &DebugSetSoftMemoryLimitResponse) -> Self {
4662 value.clone()
4663 }
4664 }
4665
4666 ///`FscacheClearRequest`
4667 ///
4668 /// <details><summary>JSON schema</summary>
4669 ///
4670 /// ```json
4671 ///{
4672 /// "type": "object",
4673 /// "properties": {
4674 /// "_async": {
4675 /// "description": "Run the command asynchronously. Returns a job id
4676 /// immediately.",
4677 /// "type": "boolean"
4678 /// },
4679 /// "_group": {
4680 /// "description": "Assign the request to a custom stats group.",
4681 /// "type": "string"
4682 /// }
4683 /// }
4684 ///}
4685 /// ```
4686 /// </details>
4687 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4688 pub struct FscacheClearRequest {
4689 ///Run the command asynchronously. Returns a job id immediately.
4690 #[serde(
4691 rename = "_async",
4692 default,
4693 skip_serializing_if = "::std::option::Option::is_none"
4694 )]
4695 pub async_: ::std::option::Option<bool>,
4696 ///Assign the request to a custom stats group.
4697 #[serde(
4698 rename = "_group",
4699 default,
4700 skip_serializing_if = "::std::option::Option::is_none"
4701 )]
4702 pub group: ::std::option::Option<::std::string::String>,
4703 }
4704
4705 impl ::std::convert::From<&FscacheClearRequest> for FscacheClearRequest {
4706 fn from(value: &FscacheClearRequest) -> Self {
4707 value.clone()
4708 }
4709 }
4710
4711 impl ::std::default::Default for FscacheClearRequest {
4712 fn default() -> Self {
4713 Self {
4714 async_: Default::default(),
4715 group: Default::default(),
4716 }
4717 }
4718 }
4719
4720 ///`FscacheClearResponse`
4721 ///
4722 /// <details><summary>JSON schema</summary>
4723 ///
4724 /// ```json
4725 ///{
4726 /// "type": "object",
4727 /// "properties": {
4728 /// "jobid": {
4729 /// "description": "Job ID returned when _async=true.",
4730 /// "type": "integer"
4731 /// }
4732 /// },
4733 /// "additionalProperties": true
4734 ///}
4735 /// ```
4736 /// </details>
4737 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4738 pub struct FscacheClearResponse {
4739 ///Job ID returned when _async=true.
4740 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4741 pub jobid: ::std::option::Option<i64>,
4742 }
4743
4744 impl ::std::convert::From<&FscacheClearResponse> for FscacheClearResponse {
4745 fn from(value: &FscacheClearResponse) -> Self {
4746 value.clone()
4747 }
4748 }
4749
4750 impl ::std::default::Default for FscacheClearResponse {
4751 fn default() -> Self {
4752 Self {
4753 jobid: Default::default(),
4754 }
4755 }
4756 }
4757
4758 ///`FscacheEntriesRequest`
4759 ///
4760 /// <details><summary>JSON schema</summary>
4761 ///
4762 /// ```json
4763 ///{
4764 /// "type": "object",
4765 /// "properties": {
4766 /// "_async": {
4767 /// "description": "Run the command asynchronously. Returns a job id
4768 /// immediately.",
4769 /// "type": "boolean"
4770 /// },
4771 /// "_group": {
4772 /// "description": "Assign the request to a custom stats group.",
4773 /// "type": "string"
4774 /// }
4775 /// }
4776 ///}
4777 /// ```
4778 /// </details>
4779 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4780 pub struct FscacheEntriesRequest {
4781 ///Run the command asynchronously. Returns a job id immediately.
4782 #[serde(
4783 rename = "_async",
4784 default,
4785 skip_serializing_if = "::std::option::Option::is_none"
4786 )]
4787 pub async_: ::std::option::Option<bool>,
4788 ///Assign the request to a custom stats group.
4789 #[serde(
4790 rename = "_group",
4791 default,
4792 skip_serializing_if = "::std::option::Option::is_none"
4793 )]
4794 pub group: ::std::option::Option<::std::string::String>,
4795 }
4796
4797 impl ::std::convert::From<&FscacheEntriesRequest> for FscacheEntriesRequest {
4798 fn from(value: &FscacheEntriesRequest) -> Self {
4799 value.clone()
4800 }
4801 }
4802
4803 impl ::std::default::Default for FscacheEntriesRequest {
4804 fn default() -> Self {
4805 Self {
4806 async_: Default::default(),
4807 group: Default::default(),
4808 }
4809 }
4810 }
4811
4812 ///`FscacheEntriesResponse`
4813 ///
4814 /// <details><summary>JSON schema</summary>
4815 ///
4816 /// ```json
4817 ///{
4818 /// "type": "object",
4819 /// "required": [
4820 /// "entries"
4821 /// ],
4822 /// "properties": {
4823 /// "entries": {
4824 /// "type": "integer"
4825 /// }
4826 /// }
4827 ///}
4828 /// ```
4829 /// </details>
4830 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4831 pub struct FscacheEntriesResponse {
4832 pub entries: i64,
4833 }
4834
4835 impl ::std::convert::From<&FscacheEntriesResponse> for FscacheEntriesResponse {
4836 fn from(value: &FscacheEntriesResponse) -> Self {
4837 value.clone()
4838 }
4839 }
4840
4841 ///`JobBatchInputsItem`
4842 ///
4843 /// <details><summary>JSON schema</summary>
4844 ///
4845 /// ```json
4846 ///{
4847 /// "type": "object",
4848 /// "required": [
4849 /// "_path"
4850 /// ],
4851 /// "properties": {
4852 /// "_path": {
4853 /// "description": "rc/path",
4854 /// "type": "string"
4855 /// }
4856 /// },
4857 /// "additionalProperties": true
4858 ///}
4859 /// ```
4860 /// </details>
4861 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4862 pub struct JobBatchInputsItem {
4863 ///rc/path
4864 #[serde(rename = "_path")]
4865 pub path: ::std::string::String,
4866 }
4867
4868 impl ::std::convert::From<&JobBatchInputsItem> for JobBatchInputsItem {
4869 fn from(value: &JobBatchInputsItem) -> Self {
4870 value.clone()
4871 }
4872 }
4873
4874 ///`JobBatchRequest`
4875 ///
4876 /// <details><summary>JSON schema</summary>
4877 ///
4878 /// ```json
4879 ///{
4880 /// "type": "object",
4881 /// "properties": {
4882 /// "_async": {
4883 /// "description": "Run the command asynchronously. Returns a job id
4884 /// immediately.",
4885 /// "type": "boolean"
4886 /// },
4887 /// "concurrency": {
4888 /// "description": "Do this many commands concurrently. Defaults to
4889 /// --transfers if not set.",
4890 /// "type": "integer"
4891 /// },
4892 /// "inputs": {
4893 /// "description": "List of inputs to the commands with an extra _path
4894 /// parameter.",
4895 /// "type": "array",
4896 /// "items": {
4897 /// "type": "object",
4898 /// "required": [
4899 /// "_path"
4900 /// ],
4901 /// "properties": {
4902 /// "_path": {
4903 /// "description": "rc/path",
4904 /// "type": "string"
4905 /// }
4906 /// },
4907 /// "additionalProperties": true
4908 /// }
4909 /// }
4910 /// }
4911 ///}
4912 /// ```
4913 /// </details>
4914 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4915 pub struct JobBatchRequest {
4916 ///Run the command asynchronously. Returns a job id immediately.
4917 #[serde(
4918 rename = "_async",
4919 default,
4920 skip_serializing_if = "::std::option::Option::is_none"
4921 )]
4922 pub async_: ::std::option::Option<bool>,
4923 ///Do this many commands concurrently. Defaults to --transfers if not
4924 /// set.
4925 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4926 pub concurrency: ::std::option::Option<i64>,
4927 ///List of inputs to the commands with an extra _path parameter.
4928 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
4929 pub inputs: ::std::vec::Vec<JobBatchRequestInputsItem>,
4930 }
4931
4932 impl ::std::convert::From<&JobBatchRequest> for JobBatchRequest {
4933 fn from(value: &JobBatchRequest) -> Self {
4934 value.clone()
4935 }
4936 }
4937
4938 impl ::std::default::Default for JobBatchRequest {
4939 fn default() -> Self {
4940 Self {
4941 async_: Default::default(),
4942 concurrency: Default::default(),
4943 inputs: Default::default(),
4944 }
4945 }
4946 }
4947
4948 ///`JobBatchRequestInputsItem`
4949 ///
4950 /// <details><summary>JSON schema</summary>
4951 ///
4952 /// ```json
4953 ///{
4954 /// "type": "object",
4955 /// "required": [
4956 /// "_path"
4957 /// ],
4958 /// "properties": {
4959 /// "_path": {
4960 /// "description": "rc/path",
4961 /// "type": "string"
4962 /// }
4963 /// },
4964 /// "additionalProperties": true
4965 ///}
4966 /// ```
4967 /// </details>
4968 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4969 pub struct JobBatchRequestInputsItem {
4970 ///rc/path
4971 #[serde(rename = "_path")]
4972 pub path: ::std::string::String,
4973 }
4974
4975 impl ::std::convert::From<&JobBatchRequestInputsItem> for JobBatchRequestInputsItem {
4976 fn from(value: &JobBatchRequestInputsItem) -> Self {
4977 value.clone()
4978 }
4979 }
4980
4981 ///`JobBatchResponse`
4982 ///
4983 /// <details><summary>JSON schema</summary>
4984 ///
4985 /// ```json
4986 ///{
4987 /// "type": "object",
4988 /// "required": [
4989 /// "executeId",
4990 /// "jobid"
4991 /// ],
4992 /// "properties": {
4993 /// "executeId": {
4994 /// "description": "Identifier for this rclone process.",
4995 /// "type": "string"
4996 /// },
4997 /// "jobid": {
4998 /// "description": "ID of the async job.",
4999 /// "type": "integer"
5000 /// }
5001 /// }
5002 ///}
5003 /// ```
5004 /// </details>
5005 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5006 pub struct JobBatchResponse {
5007 ///Identifier for this rclone process.
5008 #[serde(rename = "executeId")]
5009 pub execute_id: ::std::string::String,
5010 ///ID of the async job.
5011 pub jobid: i64,
5012 }
5013
5014 impl ::std::convert::From<&JobBatchResponse> for JobBatchResponse {
5015 fn from(value: &JobBatchResponse) -> Self {
5016 value.clone()
5017 }
5018 }
5019
5020 ///`JobListRequest`
5021 ///
5022 /// <details><summary>JSON schema</summary>
5023 ///
5024 /// ```json
5025 ///{
5026 /// "type": "object",
5027 /// "properties": {
5028 /// "_async": {
5029 /// "description": "Run the command asynchronously. Returns a job id
5030 /// immediately.",
5031 /// "type": "boolean"
5032 /// }
5033 /// }
5034 ///}
5035 /// ```
5036 /// </details>
5037 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5038 pub struct JobListRequest {
5039 ///Run the command asynchronously. Returns a job id immediately.
5040 #[serde(
5041 rename = "_async",
5042 default,
5043 skip_serializing_if = "::std::option::Option::is_none"
5044 )]
5045 pub async_: ::std::option::Option<bool>,
5046 }
5047
5048 impl ::std::convert::From<&JobListRequest> for JobListRequest {
5049 fn from(value: &JobListRequest) -> Self {
5050 value.clone()
5051 }
5052 }
5053
5054 impl ::std::default::Default for JobListRequest {
5055 fn default() -> Self {
5056 Self {
5057 async_: Default::default(),
5058 }
5059 }
5060 }
5061
5062 ///`JobListResponse`
5063 ///
5064 /// <details><summary>JSON schema</summary>
5065 ///
5066 /// ```json
5067 ///{
5068 /// "type": "object",
5069 /// "required": [
5070 /// "executeId",
5071 /// "finishedIds",
5072 /// "jobids",
5073 /// "runningIds"
5074 /// ],
5075 /// "properties": {
5076 /// "executeId": {
5077 /// "description": "Identifier for this rclone process.",
5078 /// "type": "string"
5079 /// },
5080 /// "finishedIds": {
5081 /// "description": "Array of integer job ids that are finished.",
5082 /// "type": "array",
5083 /// "items": {
5084 /// "type": "integer"
5085 /// }
5086 /// },
5087 /// "jobids": {
5088 /// "description": "Job IDs suitable for use with `job/status` and
5089 /// `job/stop`.",
5090 /// "type": "array",
5091 /// "items": {
5092 /// "type": "number"
5093 /// }
5094 /// },
5095 /// "runningIds": {
5096 /// "description": "Array of integer job ids that are running.",
5097 /// "type": "array",
5098 /// "items": {
5099 /// "type": "integer"
5100 /// }
5101 /// }
5102 /// }
5103 ///}
5104 /// ```
5105 /// </details>
5106 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5107 pub struct JobListResponse {
5108 ///Identifier for this rclone process.
5109 #[serde(rename = "executeId")]
5110 pub execute_id: ::std::string::String,
5111 ///Array of integer job ids that are finished.
5112 #[serde(rename = "finishedIds")]
5113 pub finished_ids: ::std::vec::Vec<i64>,
5114 ///Job IDs suitable for use with `job/status` and `job/stop`.
5115 pub jobids: ::std::vec::Vec<f64>,
5116 ///Array of integer job ids that are running.
5117 #[serde(rename = "runningIds")]
5118 pub running_ids: ::std::vec::Vec<i64>,
5119 }
5120
5121 impl ::std::convert::From<&JobListResponse> for JobListResponse {
5122 fn from(value: &JobListResponse) -> Self {
5123 value.clone()
5124 }
5125 }
5126
5127 ///`JobStatusRequest`
5128 ///
5129 /// <details><summary>JSON schema</summary>
5130 ///
5131 /// ```json
5132 ///{
5133 /// "type": "object",
5134 /// "properties": {
5135 /// "_async": {
5136 /// "description": "Run the command asynchronously. Returns a job id
5137 /// immediately.",
5138 /// "type": "boolean"
5139 /// },
5140 /// "jobid": {
5141 /// "description": "Numeric identifier of the job to query, as returned
5142 /// from an async call.",
5143 /// "type": "number"
5144 /// }
5145 /// }
5146 ///}
5147 /// ```
5148 /// </details>
5149 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5150 pub struct JobStatusRequest {
5151 ///Run the command asynchronously. Returns a job id immediately.
5152 #[serde(
5153 rename = "_async",
5154 default,
5155 skip_serializing_if = "::std::option::Option::is_none"
5156 )]
5157 pub async_: ::std::option::Option<bool>,
5158 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5159 pub jobid: ::std::option::Option<f64>,
5160 }
5161
5162 impl ::std::convert::From<&JobStatusRequest> for JobStatusRequest {
5163 fn from(value: &JobStatusRequest) -> Self {
5164 value.clone()
5165 }
5166 }
5167
5168 impl ::std::default::Default for JobStatusRequest {
5169 fn default() -> Self {
5170 Self {
5171 async_: Default::default(),
5172 jobid: Default::default(),
5173 }
5174 }
5175 }
5176
5177 ///`JobStatusResponse`
5178 ///
5179 /// <details><summary>JSON schema</summary>
5180 ///
5181 /// ```json
5182 ///{
5183 /// "type": "object",
5184 /// "required": [
5185 /// "duration",
5186 /// "endTime",
5187 /// "error",
5188 /// "finished",
5189 /// "id",
5190 /// "startTime",
5191 /// "success"
5192 /// ],
5193 /// "properties": {
5194 /// "duration": {
5195 /// "description": "Execution time in seconds.",
5196 /// "type": "number"
5197 /// },
5198 /// "endTime": {
5199 /// "description": "Timestamp when the job finished. (e.g.
5200 /// '2025-12-26T18:50:20.528746884+01:00')",
5201 /// "type": "string"
5202 /// },
5203 /// "error": {
5204 /// "description": "Error message, or empty string on success.",
5205 /// "type": "string"
5206 /// },
5207 /// "finished": {
5208 /// "description": "True once the job has completed.",
5209 /// "type": "boolean"
5210 /// },
5211 /// "id": {
5212 /// "description": "Job identifier.",
5213 /// "type": "number"
5214 /// },
5215 /// "output": {
5216 /// "description": "Synchronous-style output payload when available."
5217 /// },
5218 /// "progress": {
5219 /// "description": "Progress measurements supplied by the underlying
5220 /// command."
5221 /// },
5222 /// "startTime": {
5223 /// "description": "Timestamp when the job started. (e.g.
5224 /// '2025-12-24T18:50:20.5281314+01:00')",
5225 /// "type": "string"
5226 /// },
5227 /// "success": {
5228 /// "description": "True if the job completed successfully.",
5229 /// "type": "boolean"
5230 /// }
5231 /// }
5232 ///}
5233 /// ```
5234 /// </details>
5235 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5236 pub struct JobStatusResponse {
5237 pub duration: f64,
5238 ///Timestamp when the job finished. (e.g.
5239 /// '2025-12-26T18:50:20.528746884+01:00')
5240 #[serde(rename = "endTime")]
5241 pub end_time: ::std::string::String,
5242 ///Error message, or empty string on success.
5243 pub error: ::std::string::String,
5244 ///True once the job has completed.
5245 pub finished: bool,
5246 pub id: f64,
5247 ///Synchronous-style output payload when available.
5248 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5249 pub output: ::std::option::Option<::serde_json::Value>,
5250 ///Progress measurements supplied by the underlying command.
5251 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5252 pub progress: ::std::option::Option<::serde_json::Value>,
5253 ///Timestamp when the job started. (e.g.
5254 /// '2025-12-24T18:50:20.5281314+01:00')
5255 #[serde(rename = "startTime")]
5256 pub start_time: ::std::string::String,
5257 ///True if the job completed successfully.
5258 pub success: bool,
5259 }
5260
5261 impl ::std::convert::From<&JobStatusResponse> for JobStatusResponse {
5262 fn from(value: &JobStatusResponse) -> Self {
5263 value.clone()
5264 }
5265 }
5266
5267 ///`JobStopRequest`
5268 ///
5269 /// <details><summary>JSON schema</summary>
5270 ///
5271 /// ```json
5272 ///{
5273 /// "type": "object",
5274 /// "properties": {
5275 /// "_async": {
5276 /// "description": "Run the command asynchronously. Returns a job id
5277 /// immediately.",
5278 /// "type": "boolean"
5279 /// },
5280 /// "jobid": {
5281 /// "description": "Numeric identifier of the job to cancel.",
5282 /// "type": "number"
5283 /// }
5284 /// }
5285 ///}
5286 /// ```
5287 /// </details>
5288 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5289 pub struct JobStopRequest {
5290 ///Run the command asynchronously. Returns a job id immediately.
5291 #[serde(
5292 rename = "_async",
5293 default,
5294 skip_serializing_if = "::std::option::Option::is_none"
5295 )]
5296 pub async_: ::std::option::Option<bool>,
5297 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5298 pub jobid: ::std::option::Option<f64>,
5299 }
5300
5301 impl ::std::convert::From<&JobStopRequest> for JobStopRequest {
5302 fn from(value: &JobStopRequest) -> Self {
5303 value.clone()
5304 }
5305 }
5306
5307 impl ::std::default::Default for JobStopRequest {
5308 fn default() -> Self {
5309 Self {
5310 async_: Default::default(),
5311 jobid: Default::default(),
5312 }
5313 }
5314 }
5315
5316 ///`JobStopResponse`
5317 ///
5318 /// <details><summary>JSON schema</summary>
5319 ///
5320 /// ```json
5321 ///{
5322 /// "type": "object",
5323 /// "properties": {
5324 /// "jobid": {
5325 /// "description": "Job ID returned when _async=true.",
5326 /// "type": "integer"
5327 /// }
5328 /// },
5329 /// "additionalProperties": true
5330 ///}
5331 /// ```
5332 /// </details>
5333 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5334 pub struct JobStopResponse {
5335 ///Job ID returned when _async=true.
5336 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5337 pub jobid: ::std::option::Option<i64>,
5338 }
5339
5340 impl ::std::convert::From<&JobStopResponse> for JobStopResponse {
5341 fn from(value: &JobStopResponse) -> Self {
5342 value.clone()
5343 }
5344 }
5345
5346 impl ::std::default::Default for JobStopResponse {
5347 fn default() -> Self {
5348 Self {
5349 jobid: Default::default(),
5350 }
5351 }
5352 }
5353
5354 ///`JobStopgroupRequest`
5355 ///
5356 /// <details><summary>JSON schema</summary>
5357 ///
5358 /// ```json
5359 ///{
5360 /// "type": "object",
5361 /// "properties": {
5362 /// "_async": {
5363 /// "description": "Run the command asynchronously. Returns a job id
5364 /// immediately.",
5365 /// "type": "boolean"
5366 /// },
5367 /// "group": {
5368 /// "description": "Stats group name whose active jobs should be
5369 /// stopped.",
5370 /// "type": "string"
5371 /// }
5372 /// }
5373 ///}
5374 /// ```
5375 /// </details>
5376 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5377 pub struct JobStopgroupRequest {
5378 ///Run the command asynchronously. Returns a job id immediately.
5379 #[serde(
5380 rename = "_async",
5381 default,
5382 skip_serializing_if = "::std::option::Option::is_none"
5383 )]
5384 pub async_: ::std::option::Option<bool>,
5385 ///Stats group name whose active jobs should be stopped.
5386 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5387 pub group: ::std::option::Option<::std::string::String>,
5388 }
5389
5390 impl ::std::convert::From<&JobStopgroupRequest> for JobStopgroupRequest {
5391 fn from(value: &JobStopgroupRequest) -> Self {
5392 value.clone()
5393 }
5394 }
5395
5396 impl ::std::default::Default for JobStopgroupRequest {
5397 fn default() -> Self {
5398 Self {
5399 async_: Default::default(),
5400 group: Default::default(),
5401 }
5402 }
5403 }
5404
5405 ///`JobStopgroupResponse`
5406 ///
5407 /// <details><summary>JSON schema</summary>
5408 ///
5409 /// ```json
5410 ///{
5411 /// "type": "object",
5412 /// "properties": {
5413 /// "jobid": {
5414 /// "description": "Job ID returned when _async=true.",
5415 /// "type": "integer"
5416 /// }
5417 /// },
5418 /// "additionalProperties": true
5419 ///}
5420 /// ```
5421 /// </details>
5422 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5423 pub struct JobStopgroupResponse {
5424 ///Job ID returned when _async=true.
5425 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5426 pub jobid: ::std::option::Option<i64>,
5427 }
5428
5429 impl ::std::convert::From<&JobStopgroupResponse> for JobStopgroupResponse {
5430 fn from(value: &JobStopgroupResponse) -> Self {
5431 value.clone()
5432 }
5433 }
5434
5435 impl ::std::default::Default for JobStopgroupResponse {
5436 fn default() -> Self {
5437 Self {
5438 jobid: Default::default(),
5439 }
5440 }
5441 }
5442
5443 ///`MountListmountsRequest`
5444 ///
5445 /// <details><summary>JSON schema</summary>
5446 ///
5447 /// ```json
5448 ///{
5449 /// "type": "object",
5450 /// "properties": {
5451 /// "_async": {
5452 /// "description": "Run the command asynchronously. Returns a job id
5453 /// immediately.",
5454 /// "type": "boolean"
5455 /// },
5456 /// "_group": {
5457 /// "description": "Assign the request to a custom stats group.",
5458 /// "type": "string"
5459 /// }
5460 /// }
5461 ///}
5462 /// ```
5463 /// </details>
5464 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5465 pub struct MountListmountsRequest {
5466 ///Run the command asynchronously. Returns a job id immediately.
5467 #[serde(
5468 rename = "_async",
5469 default,
5470 skip_serializing_if = "::std::option::Option::is_none"
5471 )]
5472 pub async_: ::std::option::Option<bool>,
5473 ///Assign the request to a custom stats group.
5474 #[serde(
5475 rename = "_group",
5476 default,
5477 skip_serializing_if = "::std::option::Option::is_none"
5478 )]
5479 pub group: ::std::option::Option<::std::string::String>,
5480 }
5481
5482 impl ::std::convert::From<&MountListmountsRequest> for MountListmountsRequest {
5483 fn from(value: &MountListmountsRequest) -> Self {
5484 value.clone()
5485 }
5486 }
5487
5488 impl ::std::default::Default for MountListmountsRequest {
5489 fn default() -> Self {
5490 Self {
5491 async_: Default::default(),
5492 group: Default::default(),
5493 }
5494 }
5495 }
5496
5497 ///`MountListmountsResponse`
5498 ///
5499 /// <details><summary>JSON schema</summary>
5500 ///
5501 /// ```json
5502 ///{
5503 /// "type": "object",
5504 /// "required": [
5505 /// "mountPoints"
5506 /// ],
5507 /// "properties": {
5508 /// "mountPoints": {
5509 /// "type": "array",
5510 /// "items": {
5511 /// "type": "object",
5512 /// "required": [
5513 /// "Fs",
5514 /// "MountPoint",
5515 /// "MountedOn"
5516 /// ],
5517 /// "properties": {
5518 /// "Fs": {
5519 /// "type": "string"
5520 /// },
5521 /// "MountPoint": {
5522 /// "type": "string"
5523 /// },
5524 /// "MountedOn": {
5525 /// "type": "string",
5526 /// "format": "date-time"
5527 /// }
5528 /// },
5529 /// "additionalProperties": false
5530 /// }
5531 /// }
5532 /// }
5533 ///}
5534 /// ```
5535 /// </details>
5536 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5537 pub struct MountListmountsResponse {
5538 #[serde(rename = "mountPoints")]
5539 pub mount_points: ::std::vec::Vec<MountListmountsResponseMountPointsItem>,
5540 }
5541
5542 impl ::std::convert::From<&MountListmountsResponse> for MountListmountsResponse {
5543 fn from(value: &MountListmountsResponse) -> Self {
5544 value.clone()
5545 }
5546 }
5547
5548 ///`MountListmountsResponseMountPointsItem`
5549 ///
5550 /// <details><summary>JSON schema</summary>
5551 ///
5552 /// ```json
5553 ///{
5554 /// "type": "object",
5555 /// "required": [
5556 /// "Fs",
5557 /// "MountPoint",
5558 /// "MountedOn"
5559 /// ],
5560 /// "properties": {
5561 /// "Fs": {
5562 /// "type": "string"
5563 /// },
5564 /// "MountPoint": {
5565 /// "type": "string"
5566 /// },
5567 /// "MountedOn": {
5568 /// "type": "string",
5569 /// "format": "date-time"
5570 /// }
5571 /// },
5572 /// "additionalProperties": false
5573 ///}
5574 /// ```
5575 /// </details>
5576 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5577 #[serde(deny_unknown_fields)]
5578 pub struct MountListmountsResponseMountPointsItem {
5579 #[serde(rename = "Fs")]
5580 pub fs: ::std::string::String,
5581 #[serde(rename = "MountPoint")]
5582 pub mount_point: ::std::string::String,
5583 #[serde(rename = "MountedOn")]
5584 pub mounted_on: ::chrono::DateTime<::chrono::offset::Utc>,
5585 }
5586
5587 impl ::std::convert::From<&MountListmountsResponseMountPointsItem>
5588 for MountListmountsResponseMountPointsItem
5589 {
5590 fn from(value: &MountListmountsResponseMountPointsItem) -> Self {
5591 value.clone()
5592 }
5593 }
5594
5595 ///`MountMountRequest`
5596 ///
5597 /// <details><summary>JSON schema</summary>
5598 ///
5599 /// ```json
5600 ///{
5601 /// "type": "object",
5602 /// "properties": {
5603 /// "_async": {
5604 /// "description": "Run the command asynchronously. Returns a job id
5605 /// immediately.",
5606 /// "type": "boolean"
5607 /// },
5608 /// "_config": {
5609 /// "description": "JSON encoded config overrides applied for this call
5610 /// only.",
5611 /// "type": "string"
5612 /// },
5613 /// "_filter": {
5614 /// "description": "JSON encoded filter overrides applied for this call
5615 /// only.",
5616 /// "type": "string"
5617 /// },
5618 /// "_group": {
5619 /// "description": "Assign the request to a custom stats group.",
5620 /// "type": "string"
5621 /// },
5622 /// "fs": {
5623 /// "description": "Remote path to mount, such as `drive:` or
5624 /// `remote:subdir`.",
5625 /// "type": "string"
5626 /// },
5627 /// "mountOpt": {
5628 /// "description": "Mount options encoded as JSON, matching flags
5629 /// accepted by `rclone mount`.",
5630 /// "type": "string"
5631 /// },
5632 /// "mountPoint": {
5633 /// "description": "Absolute local path where the remote should be
5634 /// mounted.",
5635 /// "type": "string"
5636 /// },
5637 /// "mountType": {
5638 /// "description": "Optional mount implementation to use (`mount`,
5639 /// `cmount`, or `mount2`).",
5640 /// "type": "string"
5641 /// },
5642 /// "vfsOpt": {
5643 /// "description": "VFS options encoded as JSON, matching flags
5644 /// accepted by `rclone mount`.",
5645 /// "type": "string"
5646 /// }
5647 /// }
5648 ///}
5649 /// ```
5650 /// </details>
5651 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5652 pub struct MountMountRequest {
5653 ///Run the command asynchronously. Returns a job id immediately.
5654 #[serde(
5655 rename = "_async",
5656 default,
5657 skip_serializing_if = "::std::option::Option::is_none"
5658 )]
5659 pub async_: ::std::option::Option<bool>,
5660 ///JSON encoded config overrides applied for this call only.
5661 #[serde(
5662 rename = "_config",
5663 default,
5664 skip_serializing_if = "::std::option::Option::is_none"
5665 )]
5666 pub config: ::std::option::Option<::std::string::String>,
5667 ///JSON encoded filter overrides applied for this call only.
5668 #[serde(
5669 rename = "_filter",
5670 default,
5671 skip_serializing_if = "::std::option::Option::is_none"
5672 )]
5673 pub filter: ::std::option::Option<::std::string::String>,
5674 ///Remote path to mount, such as `drive:` or `remote:subdir`.
5675 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5676 pub fs: ::std::option::Option<::std::string::String>,
5677 ///Assign the request to a custom stats group.
5678 #[serde(
5679 rename = "_group",
5680 default,
5681 skip_serializing_if = "::std::option::Option::is_none"
5682 )]
5683 pub group: ::std::option::Option<::std::string::String>,
5684 ///Mount options encoded as JSON, matching flags accepted by `rclone
5685 /// mount`.
5686 #[serde(
5687 rename = "mountOpt",
5688 default,
5689 skip_serializing_if = "::std::option::Option::is_none"
5690 )]
5691 pub mount_opt: ::std::option::Option<::std::string::String>,
5692 ///Absolute local path where the remote should be mounted.
5693 #[serde(
5694 rename = "mountPoint",
5695 default,
5696 skip_serializing_if = "::std::option::Option::is_none"
5697 )]
5698 pub mount_point: ::std::option::Option<::std::string::String>,
5699 ///Optional mount implementation to use (`mount`, `cmount`, or
5700 /// `mount2`).
5701 #[serde(
5702 rename = "mountType",
5703 default,
5704 skip_serializing_if = "::std::option::Option::is_none"
5705 )]
5706 pub mount_type: ::std::option::Option<::std::string::String>,
5707 ///VFS options encoded as JSON, matching flags accepted by `rclone
5708 /// mount`.
5709 #[serde(
5710 rename = "vfsOpt",
5711 default,
5712 skip_serializing_if = "::std::option::Option::is_none"
5713 )]
5714 pub vfs_opt: ::std::option::Option<::std::string::String>,
5715 }
5716
5717 impl ::std::convert::From<&MountMountRequest> for MountMountRequest {
5718 fn from(value: &MountMountRequest) -> Self {
5719 value.clone()
5720 }
5721 }
5722
5723 impl ::std::default::Default for MountMountRequest {
5724 fn default() -> Self {
5725 Self {
5726 async_: Default::default(),
5727 config: Default::default(),
5728 filter: Default::default(),
5729 fs: Default::default(),
5730 group: Default::default(),
5731 mount_opt: Default::default(),
5732 mount_point: Default::default(),
5733 mount_type: Default::default(),
5734 vfs_opt: Default::default(),
5735 }
5736 }
5737 }
5738
5739 ///`MountMountResponse`
5740 ///
5741 /// <details><summary>JSON schema</summary>
5742 ///
5743 /// ```json
5744 ///{
5745 /// "type": "object",
5746 /// "properties": {
5747 /// "jobid": {
5748 /// "description": "Job ID returned when _async=true.",
5749 /// "type": "integer"
5750 /// }
5751 /// },
5752 /// "additionalProperties": true
5753 ///}
5754 /// ```
5755 /// </details>
5756 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5757 pub struct MountMountResponse {
5758 ///Job ID returned when _async=true.
5759 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5760 pub jobid: ::std::option::Option<i64>,
5761 }
5762
5763 impl ::std::convert::From<&MountMountResponse> for MountMountResponse {
5764 fn from(value: &MountMountResponse) -> Self {
5765 value.clone()
5766 }
5767 }
5768
5769 impl ::std::default::Default for MountMountResponse {
5770 fn default() -> Self {
5771 Self {
5772 jobid: Default::default(),
5773 }
5774 }
5775 }
5776
5777 ///`MountTypesRequest`
5778 ///
5779 /// <details><summary>JSON schema</summary>
5780 ///
5781 /// ```json
5782 ///{
5783 /// "type": "object",
5784 /// "properties": {
5785 /// "_async": {
5786 /// "description": "Run the command asynchronously. Returns a job id
5787 /// immediately.",
5788 /// "type": "boolean"
5789 /// },
5790 /// "_group": {
5791 /// "description": "Assign the request to a custom stats group.",
5792 /// "type": "string"
5793 /// }
5794 /// }
5795 ///}
5796 /// ```
5797 /// </details>
5798 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5799 pub struct MountTypesRequest {
5800 ///Run the command asynchronously. Returns a job id immediately.
5801 #[serde(
5802 rename = "_async",
5803 default,
5804 skip_serializing_if = "::std::option::Option::is_none"
5805 )]
5806 pub async_: ::std::option::Option<bool>,
5807 ///Assign the request to a custom stats group.
5808 #[serde(
5809 rename = "_group",
5810 default,
5811 skip_serializing_if = "::std::option::Option::is_none"
5812 )]
5813 pub group: ::std::option::Option<::std::string::String>,
5814 }
5815
5816 impl ::std::convert::From<&MountTypesRequest> for MountTypesRequest {
5817 fn from(value: &MountTypesRequest) -> Self {
5818 value.clone()
5819 }
5820 }
5821
5822 impl ::std::default::Default for MountTypesRequest {
5823 fn default() -> Self {
5824 Self {
5825 async_: Default::default(),
5826 group: Default::default(),
5827 }
5828 }
5829 }
5830
5831 ///`MountTypesResponse`
5832 ///
5833 /// <details><summary>JSON schema</summary>
5834 ///
5835 /// ```json
5836 ///{
5837 /// "type": "object",
5838 /// "required": [
5839 /// "mountTypes"
5840 /// ],
5841 /// "properties": {
5842 /// "mountTypes": {
5843 /// "type": "array",
5844 /// "items": {
5845 /// "type": "string"
5846 /// }
5847 /// }
5848 /// }
5849 ///}
5850 /// ```
5851 /// </details>
5852 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5853 pub struct MountTypesResponse {
5854 #[serde(rename = "mountTypes")]
5855 pub mount_types: ::std::vec::Vec<::std::string::String>,
5856 }
5857
5858 impl ::std::convert::From<&MountTypesResponse> for MountTypesResponse {
5859 fn from(value: &MountTypesResponse) -> Self {
5860 value.clone()
5861 }
5862 }
5863
5864 ///`MountUnmountRequest`
5865 ///
5866 /// <details><summary>JSON schema</summary>
5867 ///
5868 /// ```json
5869 ///{
5870 /// "type": "object",
5871 /// "properties": {
5872 /// "_async": {
5873 /// "description": "Run the command asynchronously. Returns a job id
5874 /// immediately.",
5875 /// "type": "boolean"
5876 /// },
5877 /// "_group": {
5878 /// "description": "Assign the request to a custom stats group.",
5879 /// "type": "string"
5880 /// },
5881 /// "mountPoint": {
5882 /// "description": "Local mount point path to unmount.",
5883 /// "type": "string"
5884 /// }
5885 /// }
5886 ///}
5887 /// ```
5888 /// </details>
5889 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5890 pub struct MountUnmountRequest {
5891 ///Run the command asynchronously. Returns a job id immediately.
5892 #[serde(
5893 rename = "_async",
5894 default,
5895 skip_serializing_if = "::std::option::Option::is_none"
5896 )]
5897 pub async_: ::std::option::Option<bool>,
5898 ///Assign the request to a custom stats group.
5899 #[serde(
5900 rename = "_group",
5901 default,
5902 skip_serializing_if = "::std::option::Option::is_none"
5903 )]
5904 pub group: ::std::option::Option<::std::string::String>,
5905 ///Local mount point path to unmount.
5906 #[serde(
5907 rename = "mountPoint",
5908 default,
5909 skip_serializing_if = "::std::option::Option::is_none"
5910 )]
5911 pub mount_point: ::std::option::Option<::std::string::String>,
5912 }
5913
5914 impl ::std::convert::From<&MountUnmountRequest> for MountUnmountRequest {
5915 fn from(value: &MountUnmountRequest) -> Self {
5916 value.clone()
5917 }
5918 }
5919
5920 impl ::std::default::Default for MountUnmountRequest {
5921 fn default() -> Self {
5922 Self {
5923 async_: Default::default(),
5924 group: Default::default(),
5925 mount_point: Default::default(),
5926 }
5927 }
5928 }
5929
5930 ///`MountUnmountResponse`
5931 ///
5932 /// <details><summary>JSON schema</summary>
5933 ///
5934 /// ```json
5935 ///{
5936 /// "type": "object",
5937 /// "properties": {
5938 /// "jobid": {
5939 /// "description": "Job ID returned when _async=true.",
5940 /// "type": "integer"
5941 /// }
5942 /// },
5943 /// "additionalProperties": true
5944 ///}
5945 /// ```
5946 /// </details>
5947 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5948 pub struct MountUnmountResponse {
5949 ///Job ID returned when _async=true.
5950 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5951 pub jobid: ::std::option::Option<i64>,
5952 }
5953
5954 impl ::std::convert::From<&MountUnmountResponse> for MountUnmountResponse {
5955 fn from(value: &MountUnmountResponse) -> Self {
5956 value.clone()
5957 }
5958 }
5959
5960 impl ::std::default::Default for MountUnmountResponse {
5961 fn default() -> Self {
5962 Self {
5963 jobid: Default::default(),
5964 }
5965 }
5966 }
5967
5968 ///`MountUnmountallRequest`
5969 ///
5970 /// <details><summary>JSON schema</summary>
5971 ///
5972 /// ```json
5973 ///{
5974 /// "type": "object",
5975 /// "properties": {
5976 /// "_async": {
5977 /// "description": "Run the command asynchronously. Returns a job id
5978 /// immediately.",
5979 /// "type": "boolean"
5980 /// },
5981 /// "_group": {
5982 /// "description": "Assign the request to a custom stats group.",
5983 /// "type": "string"
5984 /// }
5985 /// }
5986 ///}
5987 /// ```
5988 /// </details>
5989 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5990 pub struct MountUnmountallRequest {
5991 ///Run the command asynchronously. Returns a job id immediately.
5992 #[serde(
5993 rename = "_async",
5994 default,
5995 skip_serializing_if = "::std::option::Option::is_none"
5996 )]
5997 pub async_: ::std::option::Option<bool>,
5998 ///Assign the request to a custom stats group.
5999 #[serde(
6000 rename = "_group",
6001 default,
6002 skip_serializing_if = "::std::option::Option::is_none"
6003 )]
6004 pub group: ::std::option::Option<::std::string::String>,
6005 }
6006
6007 impl ::std::convert::From<&MountUnmountallRequest> for MountUnmountallRequest {
6008 fn from(value: &MountUnmountallRequest) -> Self {
6009 value.clone()
6010 }
6011 }
6012
6013 impl ::std::default::Default for MountUnmountallRequest {
6014 fn default() -> Self {
6015 Self {
6016 async_: Default::default(),
6017 group: Default::default(),
6018 }
6019 }
6020 }
6021
6022 ///`MountUnmountallResponse`
6023 ///
6024 /// <details><summary>JSON schema</summary>
6025 ///
6026 /// ```json
6027 ///{
6028 /// "type": "object",
6029 /// "properties": {
6030 /// "jobid": {
6031 /// "description": "Job ID returned when _async=true.",
6032 /// "type": "integer"
6033 /// }
6034 /// },
6035 /// "additionalProperties": true
6036 ///}
6037 /// ```
6038 /// </details>
6039 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6040 pub struct MountUnmountallResponse {
6041 ///Job ID returned when _async=true.
6042 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6043 pub jobid: ::std::option::Option<i64>,
6044 }
6045
6046 impl ::std::convert::From<&MountUnmountallResponse> for MountUnmountallResponse {
6047 fn from(value: &MountUnmountallResponse) -> Self {
6048 value.clone()
6049 }
6050 }
6051
6052 impl ::std::default::Default for MountUnmountallResponse {
6053 fn default() -> Self {
6054 Self {
6055 jobid: Default::default(),
6056 }
6057 }
6058 }
6059
6060 ///`OperationsAboutRequest`
6061 ///
6062 /// <details><summary>JSON schema</summary>
6063 ///
6064 /// ```json
6065 ///{
6066 /// "type": "object",
6067 /// "properties": {
6068 /// "_async": {
6069 /// "description": "Run the command asynchronously. Returns a job id
6070 /// immediately.",
6071 /// "type": "boolean"
6072 /// },
6073 /// "_group": {
6074 /// "description": "Assign the request to a custom stats group.",
6075 /// "type": "string"
6076 /// },
6077 /// "fs": {
6078 /// "description": "Remote name or path to query for capacity
6079 /// information.",
6080 /// "type": "string"
6081 /// }
6082 /// }
6083 ///}
6084 /// ```
6085 /// </details>
6086 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6087 pub struct OperationsAboutRequest {
6088 ///Run the command asynchronously. Returns a job id immediately.
6089 #[serde(
6090 rename = "_async",
6091 default,
6092 skip_serializing_if = "::std::option::Option::is_none"
6093 )]
6094 pub async_: ::std::option::Option<bool>,
6095 ///Remote name or path to query for capacity information.
6096 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6097 pub fs: ::std::option::Option<::std::string::String>,
6098 ///Assign the request to a custom stats group.
6099 #[serde(
6100 rename = "_group",
6101 default,
6102 skip_serializing_if = "::std::option::Option::is_none"
6103 )]
6104 pub group: ::std::option::Option<::std::string::String>,
6105 }
6106
6107 impl ::std::convert::From<&OperationsAboutRequest> for OperationsAboutRequest {
6108 fn from(value: &OperationsAboutRequest) -> Self {
6109 value.clone()
6110 }
6111 }
6112
6113 impl ::std::default::Default for OperationsAboutRequest {
6114 fn default() -> Self {
6115 Self {
6116 async_: Default::default(),
6117 fs: Default::default(),
6118 group: Default::default(),
6119 }
6120 }
6121 }
6122
6123 ///`OperationsAboutResponse`
6124 ///
6125 /// <details><summary>JSON schema</summary>
6126 ///
6127 /// ```json
6128 ///{
6129 /// "type": "object",
6130 /// "required": [
6131 /// "free",
6132 /// "total",
6133 /// "used"
6134 /// ],
6135 /// "properties": {
6136 /// "free": {
6137 /// "type": "number"
6138 /// },
6139 /// "objects": {
6140 /// "type": "number"
6141 /// },
6142 /// "other": {
6143 /// "type": "number"
6144 /// },
6145 /// "total": {
6146 /// "type": "number"
6147 /// },
6148 /// "trashed": {
6149 /// "type": "number"
6150 /// },
6151 /// "used": {
6152 /// "type": "number"
6153 /// }
6154 /// }
6155 ///}
6156 /// ```
6157 /// </details>
6158 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6159 pub struct OperationsAboutResponse {
6160 pub free: f64,
6161 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6162 pub objects: ::std::option::Option<f64>,
6163 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6164 pub other: ::std::option::Option<f64>,
6165 pub total: f64,
6166 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6167 pub trashed: ::std::option::Option<f64>,
6168 pub used: f64,
6169 }
6170
6171 impl ::std::convert::From<&OperationsAboutResponse> for OperationsAboutResponse {
6172 fn from(value: &OperationsAboutResponse) -> Self {
6173 value.clone()
6174 }
6175 }
6176
6177 ///`OperationsCheckRequest`
6178 ///
6179 /// <details><summary>JSON schema</summary>
6180 ///
6181 /// ```json
6182 ///{
6183 /// "type": "object",
6184 /// "properties": {
6185 /// "_async": {
6186 /// "description": "Run the command asynchronously. Returns a job id
6187 /// immediately.",
6188 /// "type": "boolean"
6189 /// },
6190 /// "_group": {
6191 /// "description": "Assign the request to a custom stats group.",
6192 /// "type": "string"
6193 /// },
6194 /// "checkFileFs": {
6195 /// "description": "Remote containing the checksum SUM file when using
6196 /// `checkFileHash`.",
6197 /// "type": "string"
6198 /// },
6199 /// "checkFileHash": {
6200 /// "description": "Hash name to expect in the supplied SUM file, such
6201 /// as `md5`.",
6202 /// "type": "string"
6203 /// },
6204 /// "checkFileRemote": {
6205 /// "description": "Path within `checkFileFs` to the checksum SUM
6206 /// file.",
6207 /// "type": "string"
6208 /// },
6209 /// "combined": {
6210 /// "description": "Set to true to include a combined summary report in
6211 /// the response.",
6212 /// "type": "boolean"
6213 /// },
6214 /// "differ": {
6215 /// "description": "Set to true to include differing files in the
6216 /// report.",
6217 /// "type": "boolean"
6218 /// },
6219 /// "download": {
6220 /// "description": "Set to true to read file contents during comparison
6221 /// instead of relying on hashes.",
6222 /// "type": "boolean"
6223 /// },
6224 /// "dstFs": {
6225 /// "description": "Destination remote name or path that should match
6226 /// the source.",
6227 /// "type": "string"
6228 /// },
6229 /// "error": {
6230 /// "description": "Set to true to include entries that encountered
6231 /// errors.",
6232 /// "type": "boolean"
6233 /// },
6234 /// "match": {
6235 /// "description": "Set to true to include matching files in the
6236 /// report.",
6237 /// "type": "boolean"
6238 /// },
6239 /// "missingOnDst": {
6240 /// "description": "Set to true to report files missing from the
6241 /// destination.",
6242 /// "type": "boolean"
6243 /// },
6244 /// "missingOnSrc": {
6245 /// "description": "Set to true to report files missing from the
6246 /// source.",
6247 /// "type": "boolean"
6248 /// },
6249 /// "oneWay": {
6250 /// "description": "Set to true to only ensure that source files exist
6251 /// on the destination.",
6252 /// "type": "boolean"
6253 /// },
6254 /// "srcFs": {
6255 /// "description": "Source remote name or path to verify, e.g.
6256 /// `drive:`.",
6257 /// "type": "string"
6258 /// }
6259 /// }
6260 ///}
6261 /// ```
6262 /// </details>
6263 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6264 pub struct OperationsCheckRequest {
6265 ///Run the command asynchronously. Returns a job id immediately.
6266 #[serde(
6267 rename = "_async",
6268 default,
6269 skip_serializing_if = "::std::option::Option::is_none"
6270 )]
6271 pub async_: ::std::option::Option<bool>,
6272 ///Remote containing the checksum SUM file when using `checkFileHash`.
6273 #[serde(
6274 rename = "checkFileFs",
6275 default,
6276 skip_serializing_if = "::std::option::Option::is_none"
6277 )]
6278 pub check_file_fs: ::std::option::Option<::std::string::String>,
6279 ///Hash name to expect in the supplied SUM file, such as `md5`.
6280 #[serde(
6281 rename = "checkFileHash",
6282 default,
6283 skip_serializing_if = "::std::option::Option::is_none"
6284 )]
6285 pub check_file_hash: ::std::option::Option<::std::string::String>,
6286 ///Path within `checkFileFs` to the checksum SUM file.
6287 #[serde(
6288 rename = "checkFileRemote",
6289 default,
6290 skip_serializing_if = "::std::option::Option::is_none"
6291 )]
6292 pub check_file_remote: ::std::option::Option<::std::string::String>,
6293 ///Set to true to include a combined summary report in the response.
6294 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6295 pub combined: ::std::option::Option<bool>,
6296 ///Set to true to include differing files in the report.
6297 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6298 pub differ: ::std::option::Option<bool>,
6299 ///Set to true to read file contents during comparison instead of
6300 /// relying on hashes.
6301 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6302 pub download: ::std::option::Option<bool>,
6303 ///Destination remote name or path that should match the source.
6304 #[serde(
6305 rename = "dstFs",
6306 default,
6307 skip_serializing_if = "::std::option::Option::is_none"
6308 )]
6309 pub dst_fs: ::std::option::Option<::std::string::String>,
6310 ///Set to true to include entries that encountered errors.
6311 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6312 pub error: ::std::option::Option<bool>,
6313 ///Assign the request to a custom stats group.
6314 #[serde(
6315 rename = "_group",
6316 default,
6317 skip_serializing_if = "::std::option::Option::is_none"
6318 )]
6319 pub group: ::std::option::Option<::std::string::String>,
6320 ///Set to true to include matching files in the report.
6321 #[serde(
6322 rename = "match",
6323 default,
6324 skip_serializing_if = "::std::option::Option::is_none"
6325 )]
6326 pub match_: ::std::option::Option<bool>,
6327 ///Set to true to report files missing from the destination.
6328 #[serde(
6329 rename = "missingOnDst",
6330 default,
6331 skip_serializing_if = "::std::option::Option::is_none"
6332 )]
6333 pub missing_on_dst: ::std::option::Option<bool>,
6334 ///Set to true to report files missing from the source.
6335 #[serde(
6336 rename = "missingOnSrc",
6337 default,
6338 skip_serializing_if = "::std::option::Option::is_none"
6339 )]
6340 pub missing_on_src: ::std::option::Option<bool>,
6341 ///Set to true to only ensure that source files exist on the
6342 /// destination.
6343 #[serde(
6344 rename = "oneWay",
6345 default,
6346 skip_serializing_if = "::std::option::Option::is_none"
6347 )]
6348 pub one_way: ::std::option::Option<bool>,
6349 ///Source remote name or path to verify, e.g. `drive:`.
6350 #[serde(
6351 rename = "srcFs",
6352 default,
6353 skip_serializing_if = "::std::option::Option::is_none"
6354 )]
6355 pub src_fs: ::std::option::Option<::std::string::String>,
6356 }
6357
6358 impl ::std::convert::From<&OperationsCheckRequest> for OperationsCheckRequest {
6359 fn from(value: &OperationsCheckRequest) -> Self {
6360 value.clone()
6361 }
6362 }
6363
6364 impl ::std::default::Default for OperationsCheckRequest {
6365 fn default() -> Self {
6366 Self {
6367 async_: Default::default(),
6368 check_file_fs: Default::default(),
6369 check_file_hash: Default::default(),
6370 check_file_remote: Default::default(),
6371 combined: Default::default(),
6372 differ: Default::default(),
6373 download: Default::default(),
6374 dst_fs: Default::default(),
6375 error: Default::default(),
6376 group: Default::default(),
6377 match_: Default::default(),
6378 missing_on_dst: Default::default(),
6379 missing_on_src: Default::default(),
6380 one_way: Default::default(),
6381 src_fs: Default::default(),
6382 }
6383 }
6384 }
6385
6386 ///`OperationsCheckResponse`
6387 ///
6388 /// <details><summary>JSON schema</summary>
6389 ///
6390 /// ```json
6391 ///{
6392 /// "type": "object",
6393 /// "required": [
6394 /// "status",
6395 /// "success"
6396 /// ],
6397 /// "properties": {
6398 /// "combined": {
6399 /// "description": "Combined summary lines when `combined=true` is
6400 /// requested.",
6401 /// "type": "array",
6402 /// "items": {
6403 /// "type": "string"
6404 /// }
6405 /// },
6406 /// "differ": {
6407 /// "description": "Files that differed between source and
6408 /// destination.",
6409 /// "type": "array",
6410 /// "items": {
6411 /// "type": "string"
6412 /// }
6413 /// },
6414 /// "error": {
6415 /// "description": "Entries that produced errors during the check.",
6416 /// "type": "array",
6417 /// "items": {
6418 /// "type": "string"
6419 /// }
6420 /// },
6421 /// "hashType": {
6422 /// "description": "Hash algorithm used for comparisons when
6423 /// applicable.",
6424 /// "type": "string"
6425 /// },
6426 /// "match": {
6427 /// "description": "Files that matched on both sides.",
6428 /// "type": "array",
6429 /// "items": {
6430 /// "type": "string"
6431 /// }
6432 /// },
6433 /// "missingOnDst": {
6434 /// "description": "Files present on the source but missing from the
6435 /// destination.",
6436 /// "type": "array",
6437 /// "items": {
6438 /// "type": "string"
6439 /// }
6440 /// },
6441 /// "missingOnSrc": {
6442 /// "description": "Files present on the destination but missing from
6443 /// the source.",
6444 /// "type": "array",
6445 /// "items": {
6446 /// "type": "string"
6447 /// }
6448 /// },
6449 /// "status": {
6450 /// "description": "Human readable status string.",
6451 /// "type": "string"
6452 /// },
6453 /// "success": {
6454 /// "description": "True when the check completes without differences
6455 /// or errors.",
6456 /// "type": "boolean"
6457 /// }
6458 /// }
6459 ///}
6460 /// ```
6461 /// </details>
6462 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6463 pub struct OperationsCheckResponse {
6464 ///Combined summary lines when `combined=true` is requested.
6465 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
6466 pub combined: ::std::vec::Vec<::std::string::String>,
6467 ///Files that differed between source and destination.
6468 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
6469 pub differ: ::std::vec::Vec<::std::string::String>,
6470 ///Entries that produced errors during the check.
6471 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
6472 pub error: ::std::vec::Vec<::std::string::String>,
6473 ///Hash algorithm used for comparisons when applicable.
6474 #[serde(
6475 rename = "hashType",
6476 default,
6477 skip_serializing_if = "::std::option::Option::is_none"
6478 )]
6479 pub hash_type: ::std::option::Option<::std::string::String>,
6480 ///Files that matched on both sides.
6481 #[serde(
6482 rename = "match",
6483 default,
6484 skip_serializing_if = "::std::vec::Vec::is_empty"
6485 )]
6486 pub match_: ::std::vec::Vec<::std::string::String>,
6487 ///Files present on the source but missing from the destination.
6488 #[serde(
6489 rename = "missingOnDst",
6490 default,
6491 skip_serializing_if = "::std::vec::Vec::is_empty"
6492 )]
6493 pub missing_on_dst: ::std::vec::Vec<::std::string::String>,
6494 ///Files present on the destination but missing from the source.
6495 #[serde(
6496 rename = "missingOnSrc",
6497 default,
6498 skip_serializing_if = "::std::vec::Vec::is_empty"
6499 )]
6500 pub missing_on_src: ::std::vec::Vec<::std::string::String>,
6501 ///Human readable status string.
6502 pub status: ::std::string::String,
6503 ///True when the check completes without differences or errors.
6504 pub success: bool,
6505 }
6506
6507 impl ::std::convert::From<&OperationsCheckResponse> for OperationsCheckResponse {
6508 fn from(value: &OperationsCheckResponse) -> Self {
6509 value.clone()
6510 }
6511 }
6512
6513 ///`OperationsCleanupRequest`
6514 ///
6515 /// <details><summary>JSON schema</summary>
6516 ///
6517 /// ```json
6518 ///{
6519 /// "type": "object",
6520 /// "properties": {
6521 /// "_async": {
6522 /// "description": "Run the command asynchronously. Returns a job id
6523 /// immediately.",
6524 /// "type": "boolean"
6525 /// },
6526 /// "_group": {
6527 /// "description": "Assign the request to a custom stats group.",
6528 /// "type": "string"
6529 /// },
6530 /// "fs": {
6531 /// "description": "Remote name or path to clean up, for example
6532 /// `drive:`.",
6533 /// "type": "string"
6534 /// }
6535 /// }
6536 ///}
6537 /// ```
6538 /// </details>
6539 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6540 pub struct OperationsCleanupRequest {
6541 ///Run the command asynchronously. Returns a job id immediately.
6542 #[serde(
6543 rename = "_async",
6544 default,
6545 skip_serializing_if = "::std::option::Option::is_none"
6546 )]
6547 pub async_: ::std::option::Option<bool>,
6548 ///Remote name or path to clean up, for example `drive:`.
6549 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6550 pub fs: ::std::option::Option<::std::string::String>,
6551 ///Assign the request to a custom stats group.
6552 #[serde(
6553 rename = "_group",
6554 default,
6555 skip_serializing_if = "::std::option::Option::is_none"
6556 )]
6557 pub group: ::std::option::Option<::std::string::String>,
6558 }
6559
6560 impl ::std::convert::From<&OperationsCleanupRequest> for OperationsCleanupRequest {
6561 fn from(value: &OperationsCleanupRequest) -> Self {
6562 value.clone()
6563 }
6564 }
6565
6566 impl ::std::default::Default for OperationsCleanupRequest {
6567 fn default() -> Self {
6568 Self {
6569 async_: Default::default(),
6570 fs: Default::default(),
6571 group: Default::default(),
6572 }
6573 }
6574 }
6575
6576 ///`OperationsCleanupResponse`
6577 ///
6578 /// <details><summary>JSON schema</summary>
6579 ///
6580 /// ```json
6581 ///{
6582 /// "type": "object",
6583 /// "properties": {
6584 /// "jobid": {
6585 /// "description": "Job ID returned when _async=true.",
6586 /// "type": "integer"
6587 /// }
6588 /// },
6589 /// "additionalProperties": true
6590 ///}
6591 /// ```
6592 /// </details>
6593 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6594 pub struct OperationsCleanupResponse {
6595 ///Job ID returned when _async=true.
6596 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6597 pub jobid: ::std::option::Option<i64>,
6598 }
6599
6600 impl ::std::convert::From<&OperationsCleanupResponse> for OperationsCleanupResponse {
6601 fn from(value: &OperationsCleanupResponse) -> Self {
6602 value.clone()
6603 }
6604 }
6605
6606 impl ::std::default::Default for OperationsCleanupResponse {
6607 fn default() -> Self {
6608 Self {
6609 jobid: Default::default(),
6610 }
6611 }
6612 }
6613
6614 ///`OperationsCopyfileRequest`
6615 ///
6616 /// <details><summary>JSON schema</summary>
6617 ///
6618 /// ```json
6619 ///{
6620 /// "type": "object",
6621 /// "properties": {
6622 /// "_async": {
6623 /// "description": "Run the command asynchronously. Returns a job id
6624 /// immediately.",
6625 /// "type": "boolean"
6626 /// },
6627 /// "_group": {
6628 /// "description": "Assign the request to a custom stats group.",
6629 /// "type": "string"
6630 /// },
6631 /// "dstFs": {
6632 /// "description": "Destination remote name or path, such as `drive2:`
6633 /// or `/` for local filesystem.",
6634 /// "type": "string"
6635 /// },
6636 /// "dstRemote": {
6637 /// "description": "Target path within `dstFs` where the file should be
6638 /// written.",
6639 /// "type": "string"
6640 /// },
6641 /// "srcFs": {
6642 /// "description": "Source remote name or path, such as `drive:` or `/`
6643 /// for the local filesystem.",
6644 /// "type": "string"
6645 /// },
6646 /// "srcRemote": {
6647 /// "description": "Path to the source object within `srcFs`, for
6648 /// example `dir/file.txt`.",
6649 /// "type": "string"
6650 /// }
6651 /// }
6652 ///}
6653 /// ```
6654 /// </details>
6655 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6656 pub struct OperationsCopyfileRequest {
6657 ///Run the command asynchronously. Returns a job id immediately.
6658 #[serde(
6659 rename = "_async",
6660 default,
6661 skip_serializing_if = "::std::option::Option::is_none"
6662 )]
6663 pub async_: ::std::option::Option<bool>,
6664 ///Destination remote name or path, such as `drive2:` or `/` for local
6665 /// filesystem.
6666 #[serde(
6667 rename = "dstFs",
6668 default,
6669 skip_serializing_if = "::std::option::Option::is_none"
6670 )]
6671 pub dst_fs: ::std::option::Option<::std::string::String>,
6672 ///Target path within `dstFs` where the file should be written.
6673 #[serde(
6674 rename = "dstRemote",
6675 default,
6676 skip_serializing_if = "::std::option::Option::is_none"
6677 )]
6678 pub dst_remote: ::std::option::Option<::std::string::String>,
6679 ///Assign the request to a custom stats group.
6680 #[serde(
6681 rename = "_group",
6682 default,
6683 skip_serializing_if = "::std::option::Option::is_none"
6684 )]
6685 pub group: ::std::option::Option<::std::string::String>,
6686 ///Source remote name or path, such as `drive:` or `/` for the local
6687 /// filesystem.
6688 #[serde(
6689 rename = "srcFs",
6690 default,
6691 skip_serializing_if = "::std::option::Option::is_none"
6692 )]
6693 pub src_fs: ::std::option::Option<::std::string::String>,
6694 ///Path to the source object within `srcFs`, for example
6695 /// `dir/file.txt`.
6696 #[serde(
6697 rename = "srcRemote",
6698 default,
6699 skip_serializing_if = "::std::option::Option::is_none"
6700 )]
6701 pub src_remote: ::std::option::Option<::std::string::String>,
6702 }
6703
6704 impl ::std::convert::From<&OperationsCopyfileRequest> for OperationsCopyfileRequest {
6705 fn from(value: &OperationsCopyfileRequest) -> Self {
6706 value.clone()
6707 }
6708 }
6709
6710 impl ::std::default::Default for OperationsCopyfileRequest {
6711 fn default() -> Self {
6712 Self {
6713 async_: Default::default(),
6714 dst_fs: Default::default(),
6715 dst_remote: Default::default(),
6716 group: Default::default(),
6717 src_fs: Default::default(),
6718 src_remote: Default::default(),
6719 }
6720 }
6721 }
6722
6723 ///`OperationsCopyfileResponse`
6724 ///
6725 /// <details><summary>JSON schema</summary>
6726 ///
6727 /// ```json
6728 ///{
6729 /// "type": "object",
6730 /// "properties": {
6731 /// "jobid": {
6732 /// "description": "Job ID returned when _async=true.",
6733 /// "type": "integer"
6734 /// }
6735 /// },
6736 /// "additionalProperties": true
6737 ///}
6738 /// ```
6739 /// </details>
6740 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6741 pub struct OperationsCopyfileResponse {
6742 ///Job ID returned when _async=true.
6743 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6744 pub jobid: ::std::option::Option<i64>,
6745 }
6746
6747 impl ::std::convert::From<&OperationsCopyfileResponse> for OperationsCopyfileResponse {
6748 fn from(value: &OperationsCopyfileResponse) -> Self {
6749 value.clone()
6750 }
6751 }
6752
6753 impl ::std::default::Default for OperationsCopyfileResponse {
6754 fn default() -> Self {
6755 Self {
6756 jobid: Default::default(),
6757 }
6758 }
6759 }
6760
6761 ///`OperationsCopyurlRequest`
6762 ///
6763 /// <details><summary>JSON schema</summary>
6764 ///
6765 /// ```json
6766 ///{
6767 /// "type": "object",
6768 /// "properties": {
6769 /// "_async": {
6770 /// "description": "Run the command asynchronously. Returns a job id
6771 /// immediately.",
6772 /// "type": "boolean"
6773 /// },
6774 /// "_group": {
6775 /// "description": "Assign the request to a custom stats group.",
6776 /// "type": "string"
6777 /// },
6778 /// "autoFilename": {
6779 /// "description": "Set to true to derive the destination filename from
6780 /// the URL.",
6781 /// "type": "boolean"
6782 /// },
6783 /// "fs": {
6784 /// "description": "Remote name or path that will receive the
6785 /// downloaded file, e.g. `drive:`.",
6786 /// "type": "string"
6787 /// },
6788 /// "remote": {
6789 /// "description": "Destination path within `fs` where the fetched
6790 /// object will be stored.",
6791 /// "type": "string"
6792 /// },
6793 /// "url": {
6794 /// "description": "Source URL to fetch the object from.",
6795 /// "type": "string"
6796 /// }
6797 /// }
6798 ///}
6799 /// ```
6800 /// </details>
6801 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6802 pub struct OperationsCopyurlRequest {
6803 ///Run the command asynchronously. Returns a job id immediately.
6804 #[serde(
6805 rename = "_async",
6806 default,
6807 skip_serializing_if = "::std::option::Option::is_none"
6808 )]
6809 pub async_: ::std::option::Option<bool>,
6810 ///Set to true to derive the destination filename from the URL.
6811 #[serde(
6812 rename = "autoFilename",
6813 default,
6814 skip_serializing_if = "::std::option::Option::is_none"
6815 )]
6816 pub auto_filename: ::std::option::Option<bool>,
6817 ///Remote name or path that will receive the downloaded file, e.g.
6818 /// `drive:`.
6819 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6820 pub fs: ::std::option::Option<::std::string::String>,
6821 ///Assign the request to a custom stats group.
6822 #[serde(
6823 rename = "_group",
6824 default,
6825 skip_serializing_if = "::std::option::Option::is_none"
6826 )]
6827 pub group: ::std::option::Option<::std::string::String>,
6828 ///Destination path within `fs` where the fetched object will be
6829 /// stored.
6830 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6831 pub remote: ::std::option::Option<::std::string::String>,
6832 ///Source URL to fetch the object from.
6833 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6834 pub url: ::std::option::Option<::std::string::String>,
6835 }
6836
6837 impl ::std::convert::From<&OperationsCopyurlRequest> for OperationsCopyurlRequest {
6838 fn from(value: &OperationsCopyurlRequest) -> Self {
6839 value.clone()
6840 }
6841 }
6842
6843 impl ::std::default::Default for OperationsCopyurlRequest {
6844 fn default() -> Self {
6845 Self {
6846 async_: Default::default(),
6847 auto_filename: Default::default(),
6848 fs: Default::default(),
6849 group: Default::default(),
6850 remote: Default::default(),
6851 url: Default::default(),
6852 }
6853 }
6854 }
6855
6856 ///`OperationsCopyurlResponse`
6857 ///
6858 /// <details><summary>JSON schema</summary>
6859 ///
6860 /// ```json
6861 ///{
6862 /// "type": "object",
6863 /// "properties": {
6864 /// "jobid": {
6865 /// "description": "Job ID returned when _async=true.",
6866 /// "type": "integer"
6867 /// }
6868 /// },
6869 /// "additionalProperties": true
6870 ///}
6871 /// ```
6872 /// </details>
6873 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6874 pub struct OperationsCopyurlResponse {
6875 ///Job ID returned when _async=true.
6876 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6877 pub jobid: ::std::option::Option<i64>,
6878 }
6879
6880 impl ::std::convert::From<&OperationsCopyurlResponse> for OperationsCopyurlResponse {
6881 fn from(value: &OperationsCopyurlResponse) -> Self {
6882 value.clone()
6883 }
6884 }
6885
6886 impl ::std::default::Default for OperationsCopyurlResponse {
6887 fn default() -> Self {
6888 Self {
6889 jobid: Default::default(),
6890 }
6891 }
6892 }
6893
6894 ///`OperationsDeleteRequest`
6895 ///
6896 /// <details><summary>JSON schema</summary>
6897 ///
6898 /// ```json
6899 ///{
6900 /// "type": "object",
6901 /// "properties": {
6902 /// "_async": {
6903 /// "description": "Run the command asynchronously. Returns a job id
6904 /// immediately.",
6905 /// "type": "boolean"
6906 /// },
6907 /// "_config": {
6908 /// "description": "JSON encoded config overrides applied for this call
6909 /// only.",
6910 /// "type": "string"
6911 /// },
6912 /// "_filter": {
6913 /// "description": "JSON encoded filter overrides applied for this call
6914 /// only.",
6915 /// "type": "string"
6916 /// },
6917 /// "_group": {
6918 /// "description": "Assign the request to a custom stats group.",
6919 /// "type": "string"
6920 /// },
6921 /// "fs": {
6922 /// "description": "Remote name or path whose contents should be
6923 /// removed.",
6924 /// "type": "string"
6925 /// }
6926 /// }
6927 ///}
6928 /// ```
6929 /// </details>
6930 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6931 pub struct OperationsDeleteRequest {
6932 ///Run the command asynchronously. Returns a job id immediately.
6933 #[serde(
6934 rename = "_async",
6935 default,
6936 skip_serializing_if = "::std::option::Option::is_none"
6937 )]
6938 pub async_: ::std::option::Option<bool>,
6939 ///JSON encoded config overrides applied for this call only.
6940 #[serde(
6941 rename = "_config",
6942 default,
6943 skip_serializing_if = "::std::option::Option::is_none"
6944 )]
6945 pub config: ::std::option::Option<::std::string::String>,
6946 ///JSON encoded filter overrides applied for this call only.
6947 #[serde(
6948 rename = "_filter",
6949 default,
6950 skip_serializing_if = "::std::option::Option::is_none"
6951 )]
6952 pub filter: ::std::option::Option<::std::string::String>,
6953 ///Remote name or path whose contents should be removed.
6954 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6955 pub fs: ::std::option::Option<::std::string::String>,
6956 ///Assign the request to a custom stats group.
6957 #[serde(
6958 rename = "_group",
6959 default,
6960 skip_serializing_if = "::std::option::Option::is_none"
6961 )]
6962 pub group: ::std::option::Option<::std::string::String>,
6963 }
6964
6965 impl ::std::convert::From<&OperationsDeleteRequest> for OperationsDeleteRequest {
6966 fn from(value: &OperationsDeleteRequest) -> Self {
6967 value.clone()
6968 }
6969 }
6970
6971 impl ::std::default::Default for OperationsDeleteRequest {
6972 fn default() -> Self {
6973 Self {
6974 async_: Default::default(),
6975 config: Default::default(),
6976 filter: Default::default(),
6977 fs: Default::default(),
6978 group: Default::default(),
6979 }
6980 }
6981 }
6982
6983 ///`OperationsDeleteResponse`
6984 ///
6985 /// <details><summary>JSON schema</summary>
6986 ///
6987 /// ```json
6988 ///{
6989 /// "type": "object",
6990 /// "properties": {
6991 /// "jobid": {
6992 /// "description": "Job ID returned when _async=true.",
6993 /// "type": "integer"
6994 /// }
6995 /// },
6996 /// "additionalProperties": true
6997 ///}
6998 /// ```
6999 /// </details>
7000 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7001 pub struct OperationsDeleteResponse {
7002 ///Job ID returned when _async=true.
7003 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7004 pub jobid: ::std::option::Option<i64>,
7005 }
7006
7007 impl ::std::convert::From<&OperationsDeleteResponse> for OperationsDeleteResponse {
7008 fn from(value: &OperationsDeleteResponse) -> Self {
7009 value.clone()
7010 }
7011 }
7012
7013 impl ::std::default::Default for OperationsDeleteResponse {
7014 fn default() -> Self {
7015 Self {
7016 jobid: Default::default(),
7017 }
7018 }
7019 }
7020
7021 ///`OperationsDeletefileRequest`
7022 ///
7023 /// <details><summary>JSON schema</summary>
7024 ///
7025 /// ```json
7026 ///{
7027 /// "type": "object",
7028 /// "properties": {
7029 /// "_async": {
7030 /// "description": "Run the command asynchronously. Returns a job id
7031 /// immediately.",
7032 /// "type": "boolean"
7033 /// },
7034 /// "_group": {
7035 /// "description": "Assign the request to a custom stats group.",
7036 /// "type": "string"
7037 /// },
7038 /// "fs": {
7039 /// "description": "Remote name or path that contains the file to
7040 /// delete.",
7041 /// "type": "string"
7042 /// },
7043 /// "remote": {
7044 /// "description": "Exact path to the file within `fs` that should be
7045 /// deleted.",
7046 /// "type": "string"
7047 /// }
7048 /// }
7049 ///}
7050 /// ```
7051 /// </details>
7052 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7053 pub struct OperationsDeletefileRequest {
7054 ///Run the command asynchronously. Returns a job id immediately.
7055 #[serde(
7056 rename = "_async",
7057 default,
7058 skip_serializing_if = "::std::option::Option::is_none"
7059 )]
7060 pub async_: ::std::option::Option<bool>,
7061 ///Remote name or path that contains the file to delete.
7062 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7063 pub fs: ::std::option::Option<::std::string::String>,
7064 ///Assign the request to a custom stats group.
7065 #[serde(
7066 rename = "_group",
7067 default,
7068 skip_serializing_if = "::std::option::Option::is_none"
7069 )]
7070 pub group: ::std::option::Option<::std::string::String>,
7071 ///Exact path to the file within `fs` that should be deleted.
7072 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7073 pub remote: ::std::option::Option<::std::string::String>,
7074 }
7075
7076 impl ::std::convert::From<&OperationsDeletefileRequest> for OperationsDeletefileRequest {
7077 fn from(value: &OperationsDeletefileRequest) -> Self {
7078 value.clone()
7079 }
7080 }
7081
7082 impl ::std::default::Default for OperationsDeletefileRequest {
7083 fn default() -> Self {
7084 Self {
7085 async_: Default::default(),
7086 fs: Default::default(),
7087 group: Default::default(),
7088 remote: Default::default(),
7089 }
7090 }
7091 }
7092
7093 ///`OperationsDeletefileResponse`
7094 ///
7095 /// <details><summary>JSON schema</summary>
7096 ///
7097 /// ```json
7098 ///{
7099 /// "type": "object",
7100 /// "properties": {
7101 /// "jobid": {
7102 /// "description": "Job ID returned when _async=true.",
7103 /// "type": "integer"
7104 /// }
7105 /// },
7106 /// "additionalProperties": true
7107 ///}
7108 /// ```
7109 /// </details>
7110 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7111 pub struct OperationsDeletefileResponse {
7112 ///Job ID returned when _async=true.
7113 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7114 pub jobid: ::std::option::Option<i64>,
7115 }
7116
7117 impl ::std::convert::From<&OperationsDeletefileResponse> for OperationsDeletefileResponse {
7118 fn from(value: &OperationsDeletefileResponse) -> Self {
7119 value.clone()
7120 }
7121 }
7122
7123 impl ::std::default::Default for OperationsDeletefileResponse {
7124 fn default() -> Self {
7125 Self {
7126 jobid: Default::default(),
7127 }
7128 }
7129 }
7130
7131 ///`OperationsFsinfoRequest`
7132 ///
7133 /// <details><summary>JSON schema</summary>
7134 ///
7135 /// ```json
7136 ///{
7137 /// "type": "object",
7138 /// "properties": {
7139 /// "_async": {
7140 /// "description": "Run the command asynchronously. Returns a job id
7141 /// immediately.",
7142 /// "type": "boolean"
7143 /// },
7144 /// "_group": {
7145 /// "description": "Assign the request to a custom stats group.",
7146 /// "type": "string"
7147 /// },
7148 /// "fs": {
7149 /// "description": "Remote name or path to inspect, e.g. `drive:`.",
7150 /// "type": "string"
7151 /// }
7152 /// }
7153 ///}
7154 /// ```
7155 /// </details>
7156 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7157 pub struct OperationsFsinfoRequest {
7158 ///Run the command asynchronously. Returns a job id immediately.
7159 #[serde(
7160 rename = "_async",
7161 default,
7162 skip_serializing_if = "::std::option::Option::is_none"
7163 )]
7164 pub async_: ::std::option::Option<bool>,
7165 ///Remote name or path to inspect, e.g. `drive:`.
7166 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7167 pub fs: ::std::option::Option<::std::string::String>,
7168 ///Assign the request to a custom stats group.
7169 #[serde(
7170 rename = "_group",
7171 default,
7172 skip_serializing_if = "::std::option::Option::is_none"
7173 )]
7174 pub group: ::std::option::Option<::std::string::String>,
7175 }
7176
7177 impl ::std::convert::From<&OperationsFsinfoRequest> for OperationsFsinfoRequest {
7178 fn from(value: &OperationsFsinfoRequest) -> Self {
7179 value.clone()
7180 }
7181 }
7182
7183 impl ::std::default::Default for OperationsFsinfoRequest {
7184 fn default() -> Self {
7185 Self {
7186 async_: Default::default(),
7187 fs: Default::default(),
7188 group: Default::default(),
7189 }
7190 }
7191 }
7192
7193 ///`OperationsFsinfoResponse`
7194 ///
7195 /// <details><summary>JSON schema</summary>
7196 ///
7197 /// ```json
7198 ///{
7199 /// "type": "object",
7200 /// "required": [
7201 /// "Features",
7202 /// "Hashes",
7203 /// "Name",
7204 /// "Precision",
7205 /// "Root",
7206 /// "String"
7207 /// ],
7208 /// "properties": {
7209 /// "Features": {
7210 /// "type": "object",
7211 /// "additionalProperties": {
7212 /// "type": "boolean"
7213 /// }
7214 /// },
7215 /// "Hashes": {
7216 /// "type": "array",
7217 /// "items": {
7218 /// "type": "string"
7219 /// }
7220 /// },
7221 /// "MetadataInfo": {
7222 /// "type": [
7223 /// "object",
7224 /// "null"
7225 /// ],
7226 /// "additionalProperties": true
7227 /// },
7228 /// "Name": {
7229 /// "type": "string"
7230 /// },
7231 /// "Precision": {
7232 /// "type": "number"
7233 /// },
7234 /// "Root": {
7235 /// "type": "string"
7236 /// },
7237 /// "String": {
7238 /// "type": "string"
7239 /// }
7240 /// }
7241 ///}
7242 /// ```
7243 /// </details>
7244 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7245 pub struct OperationsFsinfoResponse {
7246 #[serde(rename = "Features")]
7247 pub features: ::std::collections::HashMap<::std::string::String, bool>,
7248 #[serde(rename = "Hashes")]
7249 pub hashes: ::std::vec::Vec<::std::string::String>,
7250 #[serde(
7251 rename = "MetadataInfo",
7252 default,
7253 skip_serializing_if = "::std::option::Option::is_none"
7254 )]
7255 pub metadata_info:
7256 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7257 #[serde(rename = "Name")]
7258 pub name: ::std::string::String,
7259 #[serde(rename = "Precision")]
7260 pub precision: f64,
7261 #[serde(rename = "Root")]
7262 pub root: ::std::string::String,
7263 #[serde(rename = "String")]
7264 pub string: ::std::string::String,
7265 }
7266
7267 impl ::std::convert::From<&OperationsFsinfoResponse> for OperationsFsinfoResponse {
7268 fn from(value: &OperationsFsinfoResponse) -> Self {
7269 value.clone()
7270 }
7271 }
7272
7273 ///`OperationsHashsumRequest`
7274 ///
7275 /// <details><summary>JSON schema</summary>
7276 ///
7277 /// ```json
7278 ///{
7279 /// "type": "object",
7280 /// "properties": {
7281 /// "_async": {
7282 /// "description": "Run the command asynchronously. Returns a job id
7283 /// immediately.",
7284 /// "type": "boolean"
7285 /// },
7286 /// "_group": {
7287 /// "description": "Assign the request to a custom stats group.",
7288 /// "type": "string"
7289 /// },
7290 /// "base64": {
7291 /// "description": "Set to true to emit hash values in base64 rather
7292 /// than hexadecimal.",
7293 /// "type": "boolean"
7294 /// },
7295 /// "download": {
7296 /// "description": "Set to true to force reading the data instead of
7297 /// using remote checksums.",
7298 /// "type": "boolean"
7299 /// },
7300 /// "fs": {
7301 /// "description": "Remote name or path to hash, such as `drive:` or
7302 /// `/`.",
7303 /// "type": "string"
7304 /// },
7305 /// "hashType": {
7306 /// "description": "Hash algorithm to use, e.g. `md5`, `sha1`, or
7307 /// another supported name.",
7308 /// "type": "string"
7309 /// }
7310 /// }
7311 ///}
7312 /// ```
7313 /// </details>
7314 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7315 pub struct OperationsHashsumRequest {
7316 ///Run the command asynchronously. Returns a job id immediately.
7317 #[serde(
7318 rename = "_async",
7319 default,
7320 skip_serializing_if = "::std::option::Option::is_none"
7321 )]
7322 pub async_: ::std::option::Option<bool>,
7323 ///Set to true to emit hash values in base64 rather than hexadecimal.
7324 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7325 pub base64: ::std::option::Option<bool>,
7326 ///Set to true to force reading the data instead of using remote
7327 /// checksums.
7328 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7329 pub download: ::std::option::Option<bool>,
7330 ///Remote name or path to hash, such as `drive:` or `/`.
7331 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7332 pub fs: ::std::option::Option<::std::string::String>,
7333 ///Assign the request to a custom stats group.
7334 #[serde(
7335 rename = "_group",
7336 default,
7337 skip_serializing_if = "::std::option::Option::is_none"
7338 )]
7339 pub group: ::std::option::Option<::std::string::String>,
7340 ///Hash algorithm to use, e.g. `md5`, `sha1`, or another supported
7341 /// name.
7342 #[serde(
7343 rename = "hashType",
7344 default,
7345 skip_serializing_if = "::std::option::Option::is_none"
7346 )]
7347 pub hash_type: ::std::option::Option<::std::string::String>,
7348 }
7349
7350 impl ::std::convert::From<&OperationsHashsumRequest> for OperationsHashsumRequest {
7351 fn from(value: &OperationsHashsumRequest) -> Self {
7352 value.clone()
7353 }
7354 }
7355
7356 impl ::std::default::Default for OperationsHashsumRequest {
7357 fn default() -> Self {
7358 Self {
7359 async_: Default::default(),
7360 base64: Default::default(),
7361 download: Default::default(),
7362 fs: Default::default(),
7363 group: Default::default(),
7364 hash_type: Default::default(),
7365 }
7366 }
7367 }
7368
7369 ///`OperationsHashsumResponse`
7370 ///
7371 /// <details><summary>JSON schema</summary>
7372 ///
7373 /// ```json
7374 ///{
7375 /// "type": "object",
7376 /// "required": [
7377 /// "hashType",
7378 /// "hashsum"
7379 /// ],
7380 /// "properties": {
7381 /// "hashType": {
7382 /// "type": "string"
7383 /// },
7384 /// "hashsum": {
7385 /// "type": "array",
7386 /// "items": {
7387 /// "type": "string"
7388 /// }
7389 /// }
7390 /// }
7391 ///}
7392 /// ```
7393 /// </details>
7394 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7395 pub struct OperationsHashsumResponse {
7396 #[serde(rename = "hashType")]
7397 pub hash_type: ::std::string::String,
7398 pub hashsum: ::std::vec::Vec<::std::string::String>,
7399 }
7400
7401 impl ::std::convert::From<&OperationsHashsumResponse> for OperationsHashsumResponse {
7402 fn from(value: &OperationsHashsumResponse) -> Self {
7403 value.clone()
7404 }
7405 }
7406
7407 ///`OperationsHashsumfileRequest`
7408 ///
7409 /// <details><summary>JSON schema</summary>
7410 ///
7411 /// ```json
7412 ///{
7413 /// "type": "object",
7414 /// "properties": {
7415 /// "_async": {
7416 /// "description": "Run the command asynchronously. Returns a job id
7417 /// immediately.",
7418 /// "type": "boolean"
7419 /// },
7420 /// "_group": {
7421 /// "description": "Assign the request to a custom stats group.",
7422 /// "type": "string"
7423 /// },
7424 /// "base64": {
7425 /// "description": "Set to true to emit the hash value in base64 rather
7426 /// than hexadecimal.",
7427 /// "type": "boolean"
7428 /// },
7429 /// "download": {
7430 /// "description": "Set to true to force reading the data instead of
7431 /// using remote checksums.",
7432 /// "type": "boolean"
7433 /// },
7434 /// "fs": {
7435 /// "description": "Remote name or path containing the file to hash.",
7436 /// "type": "string"
7437 /// },
7438 /// "hashType": {
7439 /// "description": "Hash algorithm to use, e.g. `md5`, `sha1`, or
7440 /// another supported name.",
7441 /// "type": "string"
7442 /// },
7443 /// "remote": {
7444 /// "description": "Path to the specific file within `fs` to hash.",
7445 /// "type": "string"
7446 /// }
7447 /// }
7448 ///}
7449 /// ```
7450 /// </details>
7451 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7452 pub struct OperationsHashsumfileRequest {
7453 ///Run the command asynchronously. Returns a job id immediately.
7454 #[serde(
7455 rename = "_async",
7456 default,
7457 skip_serializing_if = "::std::option::Option::is_none"
7458 )]
7459 pub async_: ::std::option::Option<bool>,
7460 ///Set to true to emit the hash value in base64 rather than
7461 /// hexadecimal.
7462 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7463 pub base64: ::std::option::Option<bool>,
7464 ///Set to true to force reading the data instead of using remote
7465 /// checksums.
7466 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7467 pub download: ::std::option::Option<bool>,
7468 ///Remote name or path containing the file to hash.
7469 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7470 pub fs: ::std::option::Option<::std::string::String>,
7471 ///Assign the request to a custom stats group.
7472 #[serde(
7473 rename = "_group",
7474 default,
7475 skip_serializing_if = "::std::option::Option::is_none"
7476 )]
7477 pub group: ::std::option::Option<::std::string::String>,
7478 ///Hash algorithm to use, e.g. `md5`, `sha1`, or another supported
7479 /// name.
7480 #[serde(
7481 rename = "hashType",
7482 default,
7483 skip_serializing_if = "::std::option::Option::is_none"
7484 )]
7485 pub hash_type: ::std::option::Option<::std::string::String>,
7486 ///Path to the specific file within `fs` to hash.
7487 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7488 pub remote: ::std::option::Option<::std::string::String>,
7489 }
7490
7491 impl ::std::convert::From<&OperationsHashsumfileRequest> for OperationsHashsumfileRequest {
7492 fn from(value: &OperationsHashsumfileRequest) -> Self {
7493 value.clone()
7494 }
7495 }
7496
7497 impl ::std::default::Default for OperationsHashsumfileRequest {
7498 fn default() -> Self {
7499 Self {
7500 async_: Default::default(),
7501 base64: Default::default(),
7502 download: Default::default(),
7503 fs: Default::default(),
7504 group: Default::default(),
7505 hash_type: Default::default(),
7506 remote: Default::default(),
7507 }
7508 }
7509 }
7510
7511 ///`OperationsHashsumfileResponse`
7512 ///
7513 /// <details><summary>JSON schema</summary>
7514 ///
7515 /// ```json
7516 ///{
7517 /// "type": "object",
7518 /// "required": [
7519 /// "hash",
7520 /// "hashType"
7521 /// ],
7522 /// "properties": {
7523 /// "hash": {
7524 /// "description": "The hash value of the file.",
7525 /// "type": "string"
7526 /// },
7527 /// "hashType": {
7528 /// "description": "The hash algorithm that was used.",
7529 /// "type": "string"
7530 /// }
7531 /// }
7532 ///}
7533 /// ```
7534 /// </details>
7535 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7536 pub struct OperationsHashsumfileResponse {
7537 ///The hash value of the file.
7538 pub hash: ::std::string::String,
7539 ///The hash algorithm that was used.
7540 #[serde(rename = "hashType")]
7541 pub hash_type: ::std::string::String,
7542 }
7543
7544 impl ::std::convert::From<&OperationsHashsumfileResponse> for OperationsHashsumfileResponse {
7545 fn from(value: &OperationsHashsumfileResponse) -> Self {
7546 value.clone()
7547 }
7548 }
7549
7550 ///`OperationsListRequest`
7551 ///
7552 /// <details><summary>JSON schema</summary>
7553 ///
7554 /// ```json
7555 ///{
7556 /// "type": "object",
7557 /// "properties": {
7558 /// "_async": {
7559 /// "description": "Run the command asynchronously. Returns a job id
7560 /// immediately.",
7561 /// "type": "boolean"
7562 /// },
7563 /// "_group": {
7564 /// "description": "Assign the request to a custom stats group.",
7565 /// "type": "string"
7566 /// },
7567 /// "dirsOnly": {
7568 /// "description": "Set to true to return only directory entries.",
7569 /// "type": "boolean"
7570 /// },
7571 /// "filesOnly": {
7572 /// "description": "Set to true to return only file entries.",
7573 /// "type": "boolean"
7574 /// },
7575 /// "fs": {
7576 /// "description": "Remote name or path to list, for example
7577 /// `drive:`.",
7578 /// "type": "string"
7579 /// },
7580 /// "hashTypes": {
7581 /// "description": "Specify one or more hash algorithms to include when
7582 /// `showHash` is true (e.g. `md5`).",
7583 /// "type": "array",
7584 /// "items": {
7585 /// "type": "string"
7586 /// }
7587 /// },
7588 /// "metadata": {
7589 /// "description": "Set to true to include backend-provided metadata
7590 /// maps.",
7591 /// "type": "boolean"
7592 /// },
7593 /// "noMimeType": {
7594 /// "description": "Set to true to omit MIME type detection.",
7595 /// "type": "boolean"
7596 /// },
7597 /// "noModTime": {
7598 /// "description": "Set to true to omit modification times for faster
7599 /// listings on some backends.",
7600 /// "type": "boolean"
7601 /// },
7602 /// "opt": {
7603 /// "description": "Optional JSON-encoded object of listing flags (e.g.
7604 /// `{ \"recurse\": true, \"showHash\": true }`).",
7605 /// "type": "string"
7606 /// },
7607 /// "recurse": {
7608 /// "description": "Set to true to list directories recursively.",
7609 /// "type": "boolean"
7610 /// },
7611 /// "remote": {
7612 /// "description": "Directory path within `fs` to list; leave empty to
7613 /// target the root.",
7614 /// "type": "string"
7615 /// },
7616 /// "showEncrypted": {
7617 /// "description": "Set to true to include encrypted names when using
7618 /// crypt remotes.",
7619 /// "type": "boolean"
7620 /// },
7621 /// "showHash": {
7622 /// "description": "Set to true to include hash digests for each
7623 /// entry.",
7624 /// "type": "boolean"
7625 /// },
7626 /// "showOrigIDs": {
7627 /// "description": "Set to true to include original backend identifiers
7628 /// where available.",
7629 /// "type": "boolean"
7630 /// }
7631 /// }
7632 ///}
7633 /// ```
7634 /// </details>
7635 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7636 pub struct OperationsListRequest {
7637 ///Run the command asynchronously. Returns a job id immediately.
7638 #[serde(
7639 rename = "_async",
7640 default,
7641 skip_serializing_if = "::std::option::Option::is_none"
7642 )]
7643 pub async_: ::std::option::Option<bool>,
7644 ///Set to true to return only directory entries.
7645 #[serde(
7646 rename = "dirsOnly",
7647 default,
7648 skip_serializing_if = "::std::option::Option::is_none"
7649 )]
7650 pub dirs_only: ::std::option::Option<bool>,
7651 ///Set to true to return only file entries.
7652 #[serde(
7653 rename = "filesOnly",
7654 default,
7655 skip_serializing_if = "::std::option::Option::is_none"
7656 )]
7657 pub files_only: ::std::option::Option<bool>,
7658 ///Remote name or path to list, for example `drive:`.
7659 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7660 pub fs: ::std::option::Option<::std::string::String>,
7661 ///Assign the request to a custom stats group.
7662 #[serde(
7663 rename = "_group",
7664 default,
7665 skip_serializing_if = "::std::option::Option::is_none"
7666 )]
7667 pub group: ::std::option::Option<::std::string::String>,
7668 ///Specify one or more hash algorithms to include when `showHash` is
7669 /// true (e.g. `md5`).
7670 #[serde(
7671 rename = "hashTypes",
7672 default,
7673 skip_serializing_if = "::std::vec::Vec::is_empty"
7674 )]
7675 pub hash_types: ::std::vec::Vec<::std::string::String>,
7676 ///Set to true to include backend-provided metadata maps.
7677 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7678 pub metadata: ::std::option::Option<bool>,
7679 ///Set to true to omit MIME type detection.
7680 #[serde(
7681 rename = "noMimeType",
7682 default,
7683 skip_serializing_if = "::std::option::Option::is_none"
7684 )]
7685 pub no_mime_type: ::std::option::Option<bool>,
7686 ///Set to true to omit modification times for faster listings on some
7687 /// backends.
7688 #[serde(
7689 rename = "noModTime",
7690 default,
7691 skip_serializing_if = "::std::option::Option::is_none"
7692 )]
7693 pub no_mod_time: ::std::option::Option<bool>,
7694 ///Optional JSON-encoded object of listing flags (e.g. `{ "recurse":
7695 /// true, "showHash": true }`).
7696 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7697 pub opt: ::std::option::Option<::std::string::String>,
7698 ///Set to true to list directories recursively.
7699 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7700 pub recurse: ::std::option::Option<bool>,
7701 ///Directory path within `fs` to list; leave empty to target the root.
7702 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7703 pub remote: ::std::option::Option<::std::string::String>,
7704 ///Set to true to include encrypted names when using crypt remotes.
7705 #[serde(
7706 rename = "showEncrypted",
7707 default,
7708 skip_serializing_if = "::std::option::Option::is_none"
7709 )]
7710 pub show_encrypted: ::std::option::Option<bool>,
7711 ///Set to true to include hash digests for each entry.
7712 #[serde(
7713 rename = "showHash",
7714 default,
7715 skip_serializing_if = "::std::option::Option::is_none"
7716 )]
7717 pub show_hash: ::std::option::Option<bool>,
7718 ///Set to true to include original backend identifiers where available.
7719 #[serde(
7720 rename = "showOrigIDs",
7721 default,
7722 skip_serializing_if = "::std::option::Option::is_none"
7723 )]
7724 pub show_orig_i_ds: ::std::option::Option<bool>,
7725 }
7726
7727 impl ::std::convert::From<&OperationsListRequest> for OperationsListRequest {
7728 fn from(value: &OperationsListRequest) -> Self {
7729 value.clone()
7730 }
7731 }
7732
7733 impl ::std::default::Default for OperationsListRequest {
7734 fn default() -> Self {
7735 Self {
7736 async_: Default::default(),
7737 dirs_only: Default::default(),
7738 files_only: Default::default(),
7739 fs: Default::default(),
7740 group: Default::default(),
7741 hash_types: Default::default(),
7742 metadata: Default::default(),
7743 no_mime_type: Default::default(),
7744 no_mod_time: Default::default(),
7745 opt: Default::default(),
7746 recurse: Default::default(),
7747 remote: Default::default(),
7748 show_encrypted: Default::default(),
7749 show_hash: Default::default(),
7750 show_orig_i_ds: Default::default(),
7751 }
7752 }
7753 }
7754
7755 ///`OperationsListResponse`
7756 ///
7757 /// <details><summary>JSON schema</summary>
7758 ///
7759 /// ```json
7760 ///{
7761 /// "type": "object",
7762 /// "required": [
7763 /// "list"
7764 /// ],
7765 /// "properties": {
7766 /// "list": {
7767 /// "description": "Array of entries equivalent to the items returned
7768 /// by `rclone lsjson`.",
7769 /// "type": "array",
7770 /// "items": {
7771 /// "type": "object",
7772 /// "required": [
7773 /// "IsDir",
7774 /// "Name",
7775 /// "Path"
7776 /// ],
7777 /// "properties": {
7778 /// "Encrypted": {
7779 /// "description": "Encrypted entry name when using crypt
7780 /// remotes.",
7781 /// "type": "string"
7782 /// },
7783 /// "EncryptedPath": {
7784 /// "description": "Encrypted path when using crypt remotes.",
7785 /// "type": "string"
7786 /// },
7787 /// "Hashes": {
7788 /// "description": "Hash digests keyed by algorithm when
7789 /// requested.",
7790 /// "type": "object",
7791 /// "additionalProperties": {
7792 /// "type": "string"
7793 /// }
7794 /// },
7795 /// "ID": {
7796 /// "description": "Backend-specific identifier when provided.",
7797 /// "type": "string"
7798 /// },
7799 /// "IsBucket": {
7800 /// "description": "True for bucket/root entries on bucket-based
7801 /// remotes.",
7802 /// "type": "boolean"
7803 /// },
7804 /// "IsDir": {
7805 /// "description": "True if the entry represents a directory.",
7806 /// "type": "boolean"
7807 /// },
7808 /// "Metadata": {
7809 /// "description": "Backend-provided metadata map.",
7810 /// "type": "object",
7811 /// "additionalProperties": {}
7812 /// },
7813 /// "MimeType": {
7814 /// "description": "MIME type where available.",
7815 /// "type": "string"
7816 /// },
7817 /// "ModTime": {
7818 /// "description": "Modification timestamp in RFC3339 format.",
7819 /// "type": "string"
7820 /// },
7821 /// "Name": {
7822 /// "description": "Base name of the entry.",
7823 /// "type": "string"
7824 /// },
7825 /// "OrigID": {
7826 /// "description": "Original backend identifier when recorded.",
7827 /// "type": "string"
7828 /// },
7829 /// "Path": {
7830 /// "description": "Path relative to the requested remote root.",
7831 /// "type": "string"
7832 /// },
7833 /// "Size": {
7834 /// "description": "Object size in bytes.",
7835 /// "type": "number"
7836 /// },
7837 /// "Tier": {
7838 /// "description": "Storage class or tier, if supplied by the
7839 /// backend.",
7840 /// "type": "string"
7841 /// }
7842 /// }
7843 /// }
7844 /// }
7845 /// }
7846 ///}
7847 /// ```
7848 /// </details>
7849 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7850 pub struct OperationsListResponse {
7851 ///Array of entries equivalent to the items returned by `rclone
7852 /// lsjson`.
7853 pub list: ::std::vec::Vec<OperationsListResponseListItem>,
7854 }
7855
7856 impl ::std::convert::From<&OperationsListResponse> for OperationsListResponse {
7857 fn from(value: &OperationsListResponse) -> Self {
7858 value.clone()
7859 }
7860 }
7861
7862 ///`OperationsListResponseListItem`
7863 ///
7864 /// <details><summary>JSON schema</summary>
7865 ///
7866 /// ```json
7867 ///{
7868 /// "type": "object",
7869 /// "required": [
7870 /// "IsDir",
7871 /// "Name",
7872 /// "Path"
7873 /// ],
7874 /// "properties": {
7875 /// "Encrypted": {
7876 /// "description": "Encrypted entry name when using crypt remotes.",
7877 /// "type": "string"
7878 /// },
7879 /// "EncryptedPath": {
7880 /// "description": "Encrypted path when using crypt remotes.",
7881 /// "type": "string"
7882 /// },
7883 /// "Hashes": {
7884 /// "description": "Hash digests keyed by algorithm when requested.",
7885 /// "type": "object",
7886 /// "additionalProperties": {
7887 /// "type": "string"
7888 /// }
7889 /// },
7890 /// "ID": {
7891 /// "description": "Backend-specific identifier when provided.",
7892 /// "type": "string"
7893 /// },
7894 /// "IsBucket": {
7895 /// "description": "True for bucket/root entries on bucket-based
7896 /// remotes.",
7897 /// "type": "boolean"
7898 /// },
7899 /// "IsDir": {
7900 /// "description": "True if the entry represents a directory.",
7901 /// "type": "boolean"
7902 /// },
7903 /// "Metadata": {
7904 /// "description": "Backend-provided metadata map.",
7905 /// "type": "object",
7906 /// "additionalProperties": {}
7907 /// },
7908 /// "MimeType": {
7909 /// "description": "MIME type where available.",
7910 /// "type": "string"
7911 /// },
7912 /// "ModTime": {
7913 /// "description": "Modification timestamp in RFC3339 format.",
7914 /// "type": "string"
7915 /// },
7916 /// "Name": {
7917 /// "description": "Base name of the entry.",
7918 /// "type": "string"
7919 /// },
7920 /// "OrigID": {
7921 /// "description": "Original backend identifier when recorded.",
7922 /// "type": "string"
7923 /// },
7924 /// "Path": {
7925 /// "description": "Path relative to the requested remote root.",
7926 /// "type": "string"
7927 /// },
7928 /// "Size": {
7929 /// "description": "Object size in bytes.",
7930 /// "type": "number"
7931 /// },
7932 /// "Tier": {
7933 /// "description": "Storage class or tier, if supplied by the
7934 /// backend.",
7935 /// "type": "string"
7936 /// }
7937 /// }
7938 ///}
7939 /// ```
7940 /// </details>
7941 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7942 pub struct OperationsListResponseListItem {
7943 ///Encrypted entry name when using crypt remotes.
7944 #[serde(
7945 rename = "Encrypted",
7946 default,
7947 skip_serializing_if = "::std::option::Option::is_none"
7948 )]
7949 pub encrypted: ::std::option::Option<::std::string::String>,
7950 ///Encrypted path when using crypt remotes.
7951 #[serde(
7952 rename = "EncryptedPath",
7953 default,
7954 skip_serializing_if = "::std::option::Option::is_none"
7955 )]
7956 pub encrypted_path: ::std::option::Option<::std::string::String>,
7957 ///Hash digests keyed by algorithm when requested.
7958 #[serde(
7959 rename = "Hashes",
7960 default,
7961 skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
7962 )]
7963 pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
7964 ///Backend-specific identifier when provided.
7965 #[serde(
7966 rename = "ID",
7967 default,
7968 skip_serializing_if = "::std::option::Option::is_none"
7969 )]
7970 pub id: ::std::option::Option<::std::string::String>,
7971 ///True for bucket/root entries on bucket-based remotes.
7972 #[serde(
7973 rename = "IsBucket",
7974 default,
7975 skip_serializing_if = "::std::option::Option::is_none"
7976 )]
7977 pub is_bucket: ::std::option::Option<bool>,
7978 ///True if the entry represents a directory.
7979 #[serde(rename = "IsDir")]
7980 pub is_dir: bool,
7981 ///Backend-provided metadata map.
7982 #[serde(
7983 rename = "Metadata",
7984 default,
7985 skip_serializing_if = "::serde_json::Map::is_empty"
7986 )]
7987 pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7988 ///MIME type where available.
7989 #[serde(
7990 rename = "MimeType",
7991 default,
7992 skip_serializing_if = "::std::option::Option::is_none"
7993 )]
7994 pub mime_type: ::std::option::Option<::std::string::String>,
7995 ///Modification timestamp in RFC3339 format.
7996 #[serde(
7997 rename = "ModTime",
7998 default,
7999 skip_serializing_if = "::std::option::Option::is_none"
8000 )]
8001 pub mod_time: ::std::option::Option<::std::string::String>,
8002 ///Base name of the entry.
8003 #[serde(rename = "Name")]
8004 pub name: ::std::string::String,
8005 ///Original backend identifier when recorded.
8006 #[serde(
8007 rename = "OrigID",
8008 default,
8009 skip_serializing_if = "::std::option::Option::is_none"
8010 )]
8011 pub orig_id: ::std::option::Option<::std::string::String>,
8012 ///Path relative to the requested remote root.
8013 #[serde(rename = "Path")]
8014 pub path: ::std::string::String,
8015 #[serde(
8016 rename = "Size",
8017 default,
8018 skip_serializing_if = "::std::option::Option::is_none"
8019 )]
8020 pub size: ::std::option::Option<f64>,
8021 ///Storage class or tier, if supplied by the backend.
8022 #[serde(
8023 rename = "Tier",
8024 default,
8025 skip_serializing_if = "::std::option::Option::is_none"
8026 )]
8027 pub tier: ::std::option::Option<::std::string::String>,
8028 }
8029
8030 impl ::std::convert::From<&OperationsListResponseListItem> for OperationsListResponseListItem {
8031 fn from(value: &OperationsListResponseListItem) -> Self {
8032 value.clone()
8033 }
8034 }
8035
8036 ///`OperationsMkdirRequest`
8037 ///
8038 /// <details><summary>JSON schema</summary>
8039 ///
8040 /// ```json
8041 ///{
8042 /// "type": "object",
8043 /// "properties": {
8044 /// "_async": {
8045 /// "description": "Run the command asynchronously. Returns a job id
8046 /// immediately.",
8047 /// "type": "boolean"
8048 /// },
8049 /// "_group": {
8050 /// "description": "Assign the request to a custom stats group.",
8051 /// "type": "string"
8052 /// },
8053 /// "fs": {
8054 /// "description": "Remote name or path in which to create a
8055 /// directory.",
8056 /// "type": "string"
8057 /// },
8058 /// "remote": {
8059 /// "description": "Directory path within `fs` to create.",
8060 /// "type": "string"
8061 /// }
8062 /// }
8063 ///}
8064 /// ```
8065 /// </details>
8066 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8067 pub struct OperationsMkdirRequest {
8068 ///Run the command asynchronously. Returns a job id immediately.
8069 #[serde(
8070 rename = "_async",
8071 default,
8072 skip_serializing_if = "::std::option::Option::is_none"
8073 )]
8074 pub async_: ::std::option::Option<bool>,
8075 ///Remote name or path in which to create a directory.
8076 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8077 pub fs: ::std::option::Option<::std::string::String>,
8078 ///Assign the request to a custom stats group.
8079 #[serde(
8080 rename = "_group",
8081 default,
8082 skip_serializing_if = "::std::option::Option::is_none"
8083 )]
8084 pub group: ::std::option::Option<::std::string::String>,
8085 ///Directory path within `fs` to create.
8086 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8087 pub remote: ::std::option::Option<::std::string::String>,
8088 }
8089
8090 impl ::std::convert::From<&OperationsMkdirRequest> for OperationsMkdirRequest {
8091 fn from(value: &OperationsMkdirRequest) -> Self {
8092 value.clone()
8093 }
8094 }
8095
8096 impl ::std::default::Default for OperationsMkdirRequest {
8097 fn default() -> Self {
8098 Self {
8099 async_: Default::default(),
8100 fs: Default::default(),
8101 group: Default::default(),
8102 remote: Default::default(),
8103 }
8104 }
8105 }
8106
8107 ///`OperationsMkdirResponse`
8108 ///
8109 /// <details><summary>JSON schema</summary>
8110 ///
8111 /// ```json
8112 ///{
8113 /// "type": "object",
8114 /// "properties": {
8115 /// "jobid": {
8116 /// "description": "Job ID returned when _async=true.",
8117 /// "type": "integer"
8118 /// }
8119 /// },
8120 /// "additionalProperties": true
8121 ///}
8122 /// ```
8123 /// </details>
8124 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8125 pub struct OperationsMkdirResponse {
8126 ///Job ID returned when _async=true.
8127 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8128 pub jobid: ::std::option::Option<i64>,
8129 }
8130
8131 impl ::std::convert::From<&OperationsMkdirResponse> for OperationsMkdirResponse {
8132 fn from(value: &OperationsMkdirResponse) -> Self {
8133 value.clone()
8134 }
8135 }
8136
8137 impl ::std::default::Default for OperationsMkdirResponse {
8138 fn default() -> Self {
8139 Self {
8140 jobid: Default::default(),
8141 }
8142 }
8143 }
8144
8145 ///`OperationsMovefileRequest`
8146 ///
8147 /// <details><summary>JSON schema</summary>
8148 ///
8149 /// ```json
8150 ///{
8151 /// "type": "object",
8152 /// "properties": {
8153 /// "_async": {
8154 /// "description": "Run the command asynchronously. Returns a job id
8155 /// immediately.",
8156 /// "type": "boolean"
8157 /// },
8158 /// "_group": {
8159 /// "description": "Assign the request to a custom stats group.",
8160 /// "type": "string"
8161 /// },
8162 /// "dstFs": {
8163 /// "description": "Destination remote name or path where the file will
8164 /// be moved.",
8165 /// "type": "string"
8166 /// },
8167 /// "dstRemote": {
8168 /// "description": "Destination path within `dstFs` for the moved
8169 /// object.",
8170 /// "type": "string"
8171 /// },
8172 /// "srcFs": {
8173 /// "description": "Source remote name or path containing the file to
8174 /// move.",
8175 /// "type": "string"
8176 /// },
8177 /// "srcRemote": {
8178 /// "description": "Path to the source object within `srcFs`.",
8179 /// "type": "string"
8180 /// }
8181 /// }
8182 ///}
8183 /// ```
8184 /// </details>
8185 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8186 pub struct OperationsMovefileRequest {
8187 ///Run the command asynchronously. Returns a job id immediately.
8188 #[serde(
8189 rename = "_async",
8190 default,
8191 skip_serializing_if = "::std::option::Option::is_none"
8192 )]
8193 pub async_: ::std::option::Option<bool>,
8194 ///Destination remote name or path where the file will be moved.
8195 #[serde(
8196 rename = "dstFs",
8197 default,
8198 skip_serializing_if = "::std::option::Option::is_none"
8199 )]
8200 pub dst_fs: ::std::option::Option<::std::string::String>,
8201 ///Destination path within `dstFs` for the moved object.
8202 #[serde(
8203 rename = "dstRemote",
8204 default,
8205 skip_serializing_if = "::std::option::Option::is_none"
8206 )]
8207 pub dst_remote: ::std::option::Option<::std::string::String>,
8208 ///Assign the request to a custom stats group.
8209 #[serde(
8210 rename = "_group",
8211 default,
8212 skip_serializing_if = "::std::option::Option::is_none"
8213 )]
8214 pub group: ::std::option::Option<::std::string::String>,
8215 ///Source remote name or path containing the file to move.
8216 #[serde(
8217 rename = "srcFs",
8218 default,
8219 skip_serializing_if = "::std::option::Option::is_none"
8220 )]
8221 pub src_fs: ::std::option::Option<::std::string::String>,
8222 ///Path to the source object within `srcFs`.
8223 #[serde(
8224 rename = "srcRemote",
8225 default,
8226 skip_serializing_if = "::std::option::Option::is_none"
8227 )]
8228 pub src_remote: ::std::option::Option<::std::string::String>,
8229 }
8230
8231 impl ::std::convert::From<&OperationsMovefileRequest> for OperationsMovefileRequest {
8232 fn from(value: &OperationsMovefileRequest) -> Self {
8233 value.clone()
8234 }
8235 }
8236
8237 impl ::std::default::Default for OperationsMovefileRequest {
8238 fn default() -> Self {
8239 Self {
8240 async_: Default::default(),
8241 dst_fs: Default::default(),
8242 dst_remote: Default::default(),
8243 group: Default::default(),
8244 src_fs: Default::default(),
8245 src_remote: Default::default(),
8246 }
8247 }
8248 }
8249
8250 ///`OperationsMovefileResponse`
8251 ///
8252 /// <details><summary>JSON schema</summary>
8253 ///
8254 /// ```json
8255 ///{
8256 /// "type": "object",
8257 /// "properties": {
8258 /// "jobid": {
8259 /// "description": "Job ID returned when _async=true.",
8260 /// "type": "integer"
8261 /// }
8262 /// },
8263 /// "additionalProperties": true
8264 ///}
8265 /// ```
8266 /// </details>
8267 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8268 pub struct OperationsMovefileResponse {
8269 ///Job ID returned when _async=true.
8270 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8271 pub jobid: ::std::option::Option<i64>,
8272 }
8273
8274 impl ::std::convert::From<&OperationsMovefileResponse> for OperationsMovefileResponse {
8275 fn from(value: &OperationsMovefileResponse) -> Self {
8276 value.clone()
8277 }
8278 }
8279
8280 impl ::std::default::Default for OperationsMovefileResponse {
8281 fn default() -> Self {
8282 Self {
8283 jobid: Default::default(),
8284 }
8285 }
8286 }
8287
8288 ///`OperationsPubliclinkRequest`
8289 ///
8290 /// <details><summary>JSON schema</summary>
8291 ///
8292 /// ```json
8293 ///{
8294 /// "type": "object",
8295 /// "properties": {
8296 /// "_async": {
8297 /// "description": "Run the command asynchronously. Returns a job id
8298 /// immediately.",
8299 /// "type": "boolean"
8300 /// },
8301 /// "_group": {
8302 /// "description": "Assign the request to a custom stats group.",
8303 /// "type": "string"
8304 /// },
8305 /// "expire": {
8306 /// "description": "Optional expiration time for the public link,
8307 /// formatted as supported by the backend.",
8308 /// "type": "string"
8309 /// },
8310 /// "fs": {
8311 /// "description": "Remote name or path hosting the object for which to
8312 /// manage a public link.",
8313 /// "type": "string"
8314 /// },
8315 /// "remote": {
8316 /// "description": "Path within `fs` to the object for which to create
8317 /// or remove a public link.",
8318 /// "type": "string"
8319 /// },
8320 /// "unlink": {
8321 /// "description": "Set to true to remove an existing public link
8322 /// instead of creating one.",
8323 /// "type": "boolean"
8324 /// }
8325 /// }
8326 ///}
8327 /// ```
8328 /// </details>
8329 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8330 pub struct OperationsPubliclinkRequest {
8331 ///Run the command asynchronously. Returns a job id immediately.
8332 #[serde(
8333 rename = "_async",
8334 default,
8335 skip_serializing_if = "::std::option::Option::is_none"
8336 )]
8337 pub async_: ::std::option::Option<bool>,
8338 ///Optional expiration time for the public link, formatted as supported
8339 /// by the backend.
8340 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8341 pub expire: ::std::option::Option<::std::string::String>,
8342 ///Remote name or path hosting the object for which to manage a public
8343 /// link.
8344 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8345 pub fs: ::std::option::Option<::std::string::String>,
8346 ///Assign the request to a custom stats group.
8347 #[serde(
8348 rename = "_group",
8349 default,
8350 skip_serializing_if = "::std::option::Option::is_none"
8351 )]
8352 pub group: ::std::option::Option<::std::string::String>,
8353 ///Path within `fs` to the object for which to create or remove a
8354 /// public link.
8355 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8356 pub remote: ::std::option::Option<::std::string::String>,
8357 ///Set to true to remove an existing public link instead of creating
8358 /// one.
8359 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8360 pub unlink: ::std::option::Option<bool>,
8361 }
8362
8363 impl ::std::convert::From<&OperationsPubliclinkRequest> for OperationsPubliclinkRequest {
8364 fn from(value: &OperationsPubliclinkRequest) -> Self {
8365 value.clone()
8366 }
8367 }
8368
8369 impl ::std::default::Default for OperationsPubliclinkRequest {
8370 fn default() -> Self {
8371 Self {
8372 async_: Default::default(),
8373 expire: Default::default(),
8374 fs: Default::default(),
8375 group: Default::default(),
8376 remote: Default::default(),
8377 unlink: Default::default(),
8378 }
8379 }
8380 }
8381
8382 ///`OperationsPubliclinkResponse`
8383 ///
8384 /// <details><summary>JSON schema</summary>
8385 ///
8386 /// ```json
8387 ///{
8388 /// "type": "object",
8389 /// "required": [
8390 /// "url"
8391 /// ],
8392 /// "properties": {
8393 /// "url": {
8394 /// "type": "string",
8395 /// "format": "uri"
8396 /// }
8397 /// }
8398 ///}
8399 /// ```
8400 /// </details>
8401 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8402 pub struct OperationsPubliclinkResponse {
8403 pub url: ::std::string::String,
8404 }
8405
8406 impl ::std::convert::From<&OperationsPubliclinkResponse> for OperationsPubliclinkResponse {
8407 fn from(value: &OperationsPubliclinkResponse) -> Self {
8408 value.clone()
8409 }
8410 }
8411
8412 ///`OperationsPurgeRequest`
8413 ///
8414 /// <details><summary>JSON schema</summary>
8415 ///
8416 /// ```json
8417 ///{
8418 /// "type": "object",
8419 /// "properties": {
8420 /// "_async": {
8421 /// "description": "Run the command asynchronously. Returns a job id
8422 /// immediately.",
8423 /// "type": "boolean"
8424 /// },
8425 /// "_config": {
8426 /// "description": "JSON encoded config overrides applied for this call
8427 /// only.",
8428 /// "type": "string"
8429 /// },
8430 /// "_filter": {
8431 /// "description": "JSON encoded filter overrides applied for this call
8432 /// only.",
8433 /// "type": "string"
8434 /// },
8435 /// "_group": {
8436 /// "description": "Assign the request to a custom stats group.",
8437 /// "type": "string"
8438 /// },
8439 /// "fs": {
8440 /// "description": "Remote name or path from which to remove all
8441 /// contents.",
8442 /// "type": "string"
8443 /// },
8444 /// "remote": {
8445 /// "description": "Path within `fs` whose contents should be purged.",
8446 /// "type": "string"
8447 /// }
8448 /// }
8449 ///}
8450 /// ```
8451 /// </details>
8452 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8453 pub struct OperationsPurgeRequest {
8454 ///Run the command asynchronously. Returns a job id immediately.
8455 #[serde(
8456 rename = "_async",
8457 default,
8458 skip_serializing_if = "::std::option::Option::is_none"
8459 )]
8460 pub async_: ::std::option::Option<bool>,
8461 ///JSON encoded config overrides applied for this call only.
8462 #[serde(
8463 rename = "_config",
8464 default,
8465 skip_serializing_if = "::std::option::Option::is_none"
8466 )]
8467 pub config: ::std::option::Option<::std::string::String>,
8468 ///JSON encoded filter overrides applied for this call only.
8469 #[serde(
8470 rename = "_filter",
8471 default,
8472 skip_serializing_if = "::std::option::Option::is_none"
8473 )]
8474 pub filter: ::std::option::Option<::std::string::String>,
8475 ///Remote name or path from which to remove all contents.
8476 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8477 pub fs: ::std::option::Option<::std::string::String>,
8478 ///Assign the request to a custom stats group.
8479 #[serde(
8480 rename = "_group",
8481 default,
8482 skip_serializing_if = "::std::option::Option::is_none"
8483 )]
8484 pub group: ::std::option::Option<::std::string::String>,
8485 ///Path within `fs` whose contents should be purged.
8486 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8487 pub remote: ::std::option::Option<::std::string::String>,
8488 }
8489
8490 impl ::std::convert::From<&OperationsPurgeRequest> for OperationsPurgeRequest {
8491 fn from(value: &OperationsPurgeRequest) -> Self {
8492 value.clone()
8493 }
8494 }
8495
8496 impl ::std::default::Default for OperationsPurgeRequest {
8497 fn default() -> Self {
8498 Self {
8499 async_: Default::default(),
8500 config: Default::default(),
8501 filter: Default::default(),
8502 fs: Default::default(),
8503 group: Default::default(),
8504 remote: Default::default(),
8505 }
8506 }
8507 }
8508
8509 ///`OperationsPurgeResponse`
8510 ///
8511 /// <details><summary>JSON schema</summary>
8512 ///
8513 /// ```json
8514 ///{
8515 /// "type": "object",
8516 /// "properties": {
8517 /// "jobid": {
8518 /// "description": "Job ID returned when _async=true.",
8519 /// "type": "integer"
8520 /// }
8521 /// },
8522 /// "additionalProperties": true
8523 ///}
8524 /// ```
8525 /// </details>
8526 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8527 pub struct OperationsPurgeResponse {
8528 ///Job ID returned when _async=true.
8529 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8530 pub jobid: ::std::option::Option<i64>,
8531 }
8532
8533 impl ::std::convert::From<&OperationsPurgeResponse> for OperationsPurgeResponse {
8534 fn from(value: &OperationsPurgeResponse) -> Self {
8535 value.clone()
8536 }
8537 }
8538
8539 impl ::std::default::Default for OperationsPurgeResponse {
8540 fn default() -> Self {
8541 Self {
8542 jobid: Default::default(),
8543 }
8544 }
8545 }
8546
8547 ///`OperationsRmdirRequest`
8548 ///
8549 /// <details><summary>JSON schema</summary>
8550 ///
8551 /// ```json
8552 ///{
8553 /// "type": "object",
8554 /// "properties": {
8555 /// "_async": {
8556 /// "description": "Run the command asynchronously. Returns a job id
8557 /// immediately.",
8558 /// "type": "boolean"
8559 /// },
8560 /// "_group": {
8561 /// "description": "Assign the request to a custom stats group.",
8562 /// "type": "string"
8563 /// },
8564 /// "fs": {
8565 /// "description": "Remote name or path containing the directory to
8566 /// remove.",
8567 /// "type": "string"
8568 /// },
8569 /// "remote": {
8570 /// "description": "Directory path within `fs` to delete.",
8571 /// "type": "string"
8572 /// }
8573 /// }
8574 ///}
8575 /// ```
8576 /// </details>
8577 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8578 pub struct OperationsRmdirRequest {
8579 ///Run the command asynchronously. Returns a job id immediately.
8580 #[serde(
8581 rename = "_async",
8582 default,
8583 skip_serializing_if = "::std::option::Option::is_none"
8584 )]
8585 pub async_: ::std::option::Option<bool>,
8586 ///Remote name or path containing the directory to remove.
8587 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8588 pub fs: ::std::option::Option<::std::string::String>,
8589 ///Assign the request to a custom stats group.
8590 #[serde(
8591 rename = "_group",
8592 default,
8593 skip_serializing_if = "::std::option::Option::is_none"
8594 )]
8595 pub group: ::std::option::Option<::std::string::String>,
8596 ///Directory path within `fs` to delete.
8597 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8598 pub remote: ::std::option::Option<::std::string::String>,
8599 }
8600
8601 impl ::std::convert::From<&OperationsRmdirRequest> for OperationsRmdirRequest {
8602 fn from(value: &OperationsRmdirRequest) -> Self {
8603 value.clone()
8604 }
8605 }
8606
8607 impl ::std::default::Default for OperationsRmdirRequest {
8608 fn default() -> Self {
8609 Self {
8610 async_: Default::default(),
8611 fs: Default::default(),
8612 group: Default::default(),
8613 remote: Default::default(),
8614 }
8615 }
8616 }
8617
8618 ///`OperationsRmdirResponse`
8619 ///
8620 /// <details><summary>JSON schema</summary>
8621 ///
8622 /// ```json
8623 ///{
8624 /// "type": "object",
8625 /// "properties": {
8626 /// "jobid": {
8627 /// "description": "Job ID returned when _async=true.",
8628 /// "type": "integer"
8629 /// }
8630 /// },
8631 /// "additionalProperties": true
8632 ///}
8633 /// ```
8634 /// </details>
8635 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8636 pub struct OperationsRmdirResponse {
8637 ///Job ID returned when _async=true.
8638 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8639 pub jobid: ::std::option::Option<i64>,
8640 }
8641
8642 impl ::std::convert::From<&OperationsRmdirResponse> for OperationsRmdirResponse {
8643 fn from(value: &OperationsRmdirResponse) -> Self {
8644 value.clone()
8645 }
8646 }
8647
8648 impl ::std::default::Default for OperationsRmdirResponse {
8649 fn default() -> Self {
8650 Self {
8651 jobid: Default::default(),
8652 }
8653 }
8654 }
8655
8656 ///`OperationsRmdirsRequest`
8657 ///
8658 /// <details><summary>JSON schema</summary>
8659 ///
8660 /// ```json
8661 ///{
8662 /// "type": "object",
8663 /// "properties": {
8664 /// "_async": {
8665 /// "description": "Run the command asynchronously. Returns a job id
8666 /// immediately.",
8667 /// "type": "boolean"
8668 /// },
8669 /// "_group": {
8670 /// "description": "Assign the request to a custom stats group.",
8671 /// "type": "string"
8672 /// },
8673 /// "fs": {
8674 /// "description": "Remote name or path to scan for empty
8675 /// directories.",
8676 /// "type": "string"
8677 /// },
8678 /// "leaveRoot": {
8679 /// "description": "Set to true to preserve the top-level directory
8680 /// even if empty.",
8681 /// "type": "boolean"
8682 /// },
8683 /// "remote": {
8684 /// "description": "Path within `fs` whose empty subdirectories should
8685 /// be removed.",
8686 /// "type": "string"
8687 /// }
8688 /// }
8689 ///}
8690 /// ```
8691 /// </details>
8692 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8693 pub struct OperationsRmdirsRequest {
8694 ///Run the command asynchronously. Returns a job id immediately.
8695 #[serde(
8696 rename = "_async",
8697 default,
8698 skip_serializing_if = "::std::option::Option::is_none"
8699 )]
8700 pub async_: ::std::option::Option<bool>,
8701 ///Remote name or path to scan for empty directories.
8702 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8703 pub fs: ::std::option::Option<::std::string::String>,
8704 ///Assign the request to a custom stats group.
8705 #[serde(
8706 rename = "_group",
8707 default,
8708 skip_serializing_if = "::std::option::Option::is_none"
8709 )]
8710 pub group: ::std::option::Option<::std::string::String>,
8711 ///Set to true to preserve the top-level directory even if empty.
8712 #[serde(
8713 rename = "leaveRoot",
8714 default,
8715 skip_serializing_if = "::std::option::Option::is_none"
8716 )]
8717 pub leave_root: ::std::option::Option<bool>,
8718 ///Path within `fs` whose empty subdirectories should be removed.
8719 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8720 pub remote: ::std::option::Option<::std::string::String>,
8721 }
8722
8723 impl ::std::convert::From<&OperationsRmdirsRequest> for OperationsRmdirsRequest {
8724 fn from(value: &OperationsRmdirsRequest) -> Self {
8725 value.clone()
8726 }
8727 }
8728
8729 impl ::std::default::Default for OperationsRmdirsRequest {
8730 fn default() -> Self {
8731 Self {
8732 async_: Default::default(),
8733 fs: Default::default(),
8734 group: Default::default(),
8735 leave_root: Default::default(),
8736 remote: Default::default(),
8737 }
8738 }
8739 }
8740
8741 ///`OperationsRmdirsResponse`
8742 ///
8743 /// <details><summary>JSON schema</summary>
8744 ///
8745 /// ```json
8746 ///{
8747 /// "type": "object",
8748 /// "properties": {
8749 /// "jobid": {
8750 /// "description": "Job ID returned when _async=true.",
8751 /// "type": "integer"
8752 /// }
8753 /// },
8754 /// "additionalProperties": true
8755 ///}
8756 /// ```
8757 /// </details>
8758 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8759 pub struct OperationsRmdirsResponse {
8760 ///Job ID returned when _async=true.
8761 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8762 pub jobid: ::std::option::Option<i64>,
8763 }
8764
8765 impl ::std::convert::From<&OperationsRmdirsResponse> for OperationsRmdirsResponse {
8766 fn from(value: &OperationsRmdirsResponse) -> Self {
8767 value.clone()
8768 }
8769 }
8770
8771 impl ::std::default::Default for OperationsRmdirsResponse {
8772 fn default() -> Self {
8773 Self {
8774 jobid: Default::default(),
8775 }
8776 }
8777 }
8778
8779 ///`OperationsSettierRequest`
8780 ///
8781 /// <details><summary>JSON schema</summary>
8782 ///
8783 /// ```json
8784 ///{
8785 /// "type": "object",
8786 /// "properties": {
8787 /// "_async": {
8788 /// "description": "Run the command asynchronously. Returns a job id
8789 /// immediately.",
8790 /// "type": "boolean"
8791 /// },
8792 /// "_group": {
8793 /// "description": "Assign the request to a custom stats group.",
8794 /// "type": "string"
8795 /// },
8796 /// "fs": {
8797 /// "description": "Remote name or path whose storage class tier should
8798 /// be changed.",
8799 /// "type": "string"
8800 /// }
8801 /// }
8802 ///}
8803 /// ```
8804 /// </details>
8805 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8806 pub struct OperationsSettierRequest {
8807 ///Run the command asynchronously. Returns a job id immediately.
8808 #[serde(
8809 rename = "_async",
8810 default,
8811 skip_serializing_if = "::std::option::Option::is_none"
8812 )]
8813 pub async_: ::std::option::Option<bool>,
8814 ///Remote name or path whose storage class tier should be changed.
8815 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8816 pub fs: ::std::option::Option<::std::string::String>,
8817 ///Assign the request to a custom stats group.
8818 #[serde(
8819 rename = "_group",
8820 default,
8821 skip_serializing_if = "::std::option::Option::is_none"
8822 )]
8823 pub group: ::std::option::Option<::std::string::String>,
8824 }
8825
8826 impl ::std::convert::From<&OperationsSettierRequest> for OperationsSettierRequest {
8827 fn from(value: &OperationsSettierRequest) -> Self {
8828 value.clone()
8829 }
8830 }
8831
8832 impl ::std::default::Default for OperationsSettierRequest {
8833 fn default() -> Self {
8834 Self {
8835 async_: Default::default(),
8836 fs: Default::default(),
8837 group: Default::default(),
8838 }
8839 }
8840 }
8841
8842 ///`OperationsSettierResponse`
8843 ///
8844 /// <details><summary>JSON schema</summary>
8845 ///
8846 /// ```json
8847 ///{
8848 /// "type": "object",
8849 /// "properties": {
8850 /// "jobid": {
8851 /// "description": "Job ID returned when _async=true.",
8852 /// "type": "integer"
8853 /// }
8854 /// },
8855 /// "additionalProperties": true
8856 ///}
8857 /// ```
8858 /// </details>
8859 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8860 pub struct OperationsSettierResponse {
8861 ///Job ID returned when _async=true.
8862 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8863 pub jobid: ::std::option::Option<i64>,
8864 }
8865
8866 impl ::std::convert::From<&OperationsSettierResponse> for OperationsSettierResponse {
8867 fn from(value: &OperationsSettierResponse) -> Self {
8868 value.clone()
8869 }
8870 }
8871
8872 impl ::std::default::Default for OperationsSettierResponse {
8873 fn default() -> Self {
8874 Self {
8875 jobid: Default::default(),
8876 }
8877 }
8878 }
8879
8880 ///`OperationsSettierfileRequest`
8881 ///
8882 /// <details><summary>JSON schema</summary>
8883 ///
8884 /// ```json
8885 ///{
8886 /// "type": "object",
8887 /// "properties": {
8888 /// "_async": {
8889 /// "description": "Run the command asynchronously. Returns a job id
8890 /// immediately.",
8891 /// "type": "boolean"
8892 /// },
8893 /// "_group": {
8894 /// "description": "Assign the request to a custom stats group.",
8895 /// "type": "string"
8896 /// },
8897 /// "fs": {
8898 /// "description": "Remote name or path that contains the object whose
8899 /// tier should change.",
8900 /// "type": "string"
8901 /// },
8902 /// "remote": {
8903 /// "description": "Path within `fs` to the object whose storage class
8904 /// tier should be updated.",
8905 /// "type": "string"
8906 /// }
8907 /// }
8908 ///}
8909 /// ```
8910 /// </details>
8911 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8912 pub struct OperationsSettierfileRequest {
8913 ///Run the command asynchronously. Returns a job id immediately.
8914 #[serde(
8915 rename = "_async",
8916 default,
8917 skip_serializing_if = "::std::option::Option::is_none"
8918 )]
8919 pub async_: ::std::option::Option<bool>,
8920 ///Remote name or path that contains the object whose tier should
8921 /// change.
8922 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8923 pub fs: ::std::option::Option<::std::string::String>,
8924 ///Assign the request to a custom stats group.
8925 #[serde(
8926 rename = "_group",
8927 default,
8928 skip_serializing_if = "::std::option::Option::is_none"
8929 )]
8930 pub group: ::std::option::Option<::std::string::String>,
8931 ///Path within `fs` to the object whose storage class tier should be
8932 /// updated.
8933 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8934 pub remote: ::std::option::Option<::std::string::String>,
8935 }
8936
8937 impl ::std::convert::From<&OperationsSettierfileRequest> for OperationsSettierfileRequest {
8938 fn from(value: &OperationsSettierfileRequest) -> Self {
8939 value.clone()
8940 }
8941 }
8942
8943 impl ::std::default::Default for OperationsSettierfileRequest {
8944 fn default() -> Self {
8945 Self {
8946 async_: Default::default(),
8947 fs: Default::default(),
8948 group: Default::default(),
8949 remote: Default::default(),
8950 }
8951 }
8952 }
8953
8954 ///`OperationsSettierfileResponse`
8955 ///
8956 /// <details><summary>JSON schema</summary>
8957 ///
8958 /// ```json
8959 ///{
8960 /// "type": "object",
8961 /// "properties": {
8962 /// "jobid": {
8963 /// "description": "Job ID returned when _async=true.",
8964 /// "type": "integer"
8965 /// }
8966 /// },
8967 /// "additionalProperties": true
8968 ///}
8969 /// ```
8970 /// </details>
8971 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8972 pub struct OperationsSettierfileResponse {
8973 ///Job ID returned when _async=true.
8974 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8975 pub jobid: ::std::option::Option<i64>,
8976 }
8977
8978 impl ::std::convert::From<&OperationsSettierfileResponse> for OperationsSettierfileResponse {
8979 fn from(value: &OperationsSettierfileResponse) -> Self {
8980 value.clone()
8981 }
8982 }
8983
8984 impl ::std::default::Default for OperationsSettierfileResponse {
8985 fn default() -> Self {
8986 Self {
8987 jobid: Default::default(),
8988 }
8989 }
8990 }
8991
8992 ///`OperationsSizeRequest`
8993 ///
8994 /// <details><summary>JSON schema</summary>
8995 ///
8996 /// ```json
8997 ///{
8998 /// "type": "object",
8999 /// "properties": {
9000 /// "_async": {
9001 /// "description": "Run the command asynchronously. Returns a job id
9002 /// immediately.",
9003 /// "type": "boolean"
9004 /// },
9005 /// "_group": {
9006 /// "description": "Assign the request to a custom stats group.",
9007 /// "type": "string"
9008 /// },
9009 /// "fs": {
9010 /// "description": "Remote name or path to measure aggregate size
9011 /// information for.",
9012 /// "type": "string"
9013 /// }
9014 /// }
9015 ///}
9016 /// ```
9017 /// </details>
9018 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9019 pub struct OperationsSizeRequest {
9020 ///Run the command asynchronously. Returns a job id immediately.
9021 #[serde(
9022 rename = "_async",
9023 default,
9024 skip_serializing_if = "::std::option::Option::is_none"
9025 )]
9026 pub async_: ::std::option::Option<bool>,
9027 ///Remote name or path to measure aggregate size information for.
9028 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9029 pub fs: ::std::option::Option<::std::string::String>,
9030 ///Assign the request to a custom stats group.
9031 #[serde(
9032 rename = "_group",
9033 default,
9034 skip_serializing_if = "::std::option::Option::is_none"
9035 )]
9036 pub group: ::std::option::Option<::std::string::String>,
9037 }
9038
9039 impl ::std::convert::From<&OperationsSizeRequest> for OperationsSizeRequest {
9040 fn from(value: &OperationsSizeRequest) -> Self {
9041 value.clone()
9042 }
9043 }
9044
9045 impl ::std::default::Default for OperationsSizeRequest {
9046 fn default() -> Self {
9047 Self {
9048 async_: Default::default(),
9049 fs: Default::default(),
9050 group: Default::default(),
9051 }
9052 }
9053 }
9054
9055 ///`OperationsSizeResponse`
9056 ///
9057 /// <details><summary>JSON schema</summary>
9058 ///
9059 /// ```json
9060 ///{
9061 /// "type": "object",
9062 /// "required": [
9063 /// "bytes",
9064 /// "count",
9065 /// "sizeless"
9066 /// ],
9067 /// "properties": {
9068 /// "bytes": {
9069 /// "type": "number"
9070 /// },
9071 /// "count": {
9072 /// "type": "integer"
9073 /// },
9074 /// "sizeless": {
9075 /// "type": "integer"
9076 /// }
9077 /// }
9078 ///}
9079 /// ```
9080 /// </details>
9081 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9082 pub struct OperationsSizeResponse {
9083 pub bytes: f64,
9084 pub count: i64,
9085 pub sizeless: i64,
9086 }
9087
9088 impl ::std::convert::From<&OperationsSizeResponse> for OperationsSizeResponse {
9089 fn from(value: &OperationsSizeResponse) -> Self {
9090 value.clone()
9091 }
9092 }
9093
9094 ///`OperationsStatRequest`
9095 ///
9096 /// <details><summary>JSON schema</summary>
9097 ///
9098 /// ```json
9099 ///{
9100 /// "type": "object",
9101 /// "properties": {
9102 /// "_async": {
9103 /// "description": "Run the command asynchronously. Returns a job id
9104 /// immediately.",
9105 /// "type": "boolean"
9106 /// },
9107 /// "_group": {
9108 /// "description": "Assign the request to a custom stats group.",
9109 /// "type": "string"
9110 /// },
9111 /// "fs": {
9112 /// "description": "Remote name or path that contains the item to
9113 /// inspect.",
9114 /// "type": "string"
9115 /// },
9116 /// "opt": {
9117 /// "description": "Optional JSON object of listing flags, matching
9118 /// those accepted by `operations/list`.",
9119 /// "type": "string"
9120 /// },
9121 /// "remote": {
9122 /// "description": "Path to the file or directory within `fs` to
9123 /// describe.",
9124 /// "type": "string"
9125 /// }
9126 /// }
9127 ///}
9128 /// ```
9129 /// </details>
9130 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9131 pub struct OperationsStatRequest {
9132 ///Run the command asynchronously. Returns a job id immediately.
9133 #[serde(
9134 rename = "_async",
9135 default,
9136 skip_serializing_if = "::std::option::Option::is_none"
9137 )]
9138 pub async_: ::std::option::Option<bool>,
9139 ///Remote name or path that contains the item to inspect.
9140 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9141 pub fs: ::std::option::Option<::std::string::String>,
9142 ///Assign the request to a custom stats group.
9143 #[serde(
9144 rename = "_group",
9145 default,
9146 skip_serializing_if = "::std::option::Option::is_none"
9147 )]
9148 pub group: ::std::option::Option<::std::string::String>,
9149 ///Optional JSON object of listing flags, matching those accepted by
9150 /// `operations/list`.
9151 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9152 pub opt: ::std::option::Option<::std::string::String>,
9153 ///Path to the file or directory within `fs` to describe.
9154 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9155 pub remote: ::std::option::Option<::std::string::String>,
9156 }
9157
9158 impl ::std::convert::From<&OperationsStatRequest> for OperationsStatRequest {
9159 fn from(value: &OperationsStatRequest) -> Self {
9160 value.clone()
9161 }
9162 }
9163
9164 impl ::std::default::Default for OperationsStatRequest {
9165 fn default() -> Self {
9166 Self {
9167 async_: Default::default(),
9168 fs: Default::default(),
9169 group: Default::default(),
9170 opt: Default::default(),
9171 remote: Default::default(),
9172 }
9173 }
9174 }
9175
9176 ///`OperationsStatResponse`
9177 ///
9178 /// <details><summary>JSON schema</summary>
9179 ///
9180 /// ```json
9181 ///{
9182 /// "type": "object",
9183 /// "required": [
9184 /// "item"
9185 /// ],
9186 /// "properties": {
9187 /// "item": {
9188 /// "type": [
9189 /// "object",
9190 /// "null"
9191 /// ],
9192 /// "required": [
9193 /// "IsDir",
9194 /// "MimeType",
9195 /// "ModTime",
9196 /// "Name",
9197 /// "Path",
9198 /// "Size"
9199 /// ],
9200 /// "properties": {
9201 /// "Encrypted": {
9202 /// "description": "Encrypted entry name when using crypt
9203 /// remotes.",
9204 /// "type": "string"
9205 /// },
9206 /// "EncryptedPath": {
9207 /// "description": "Encrypted path when using crypt remotes.",
9208 /// "type": "string"
9209 /// },
9210 /// "Hashes": {
9211 /// "description": "Hash digests keyed by algorithm when
9212 /// requested.",
9213 /// "type": "object",
9214 /// "additionalProperties": {
9215 /// "type": "string"
9216 /// }
9217 /// },
9218 /// "ID": {
9219 /// "description": "Backend-specific identifier when provided.",
9220 /// "type": "string"
9221 /// },
9222 /// "IsBucket": {
9223 /// "description": "True for bucket/root entries on bucket-based
9224 /// remotes.",
9225 /// "type": "boolean"
9226 /// },
9227 /// "IsDir": {
9228 /// "description": "True if the entry is a directory.",
9229 /// "type": "boolean"
9230 /// },
9231 /// "Metadata": {
9232 /// "description": "Backend-provided metadata map.",
9233 /// "type": "object",
9234 /// "additionalProperties": {}
9235 /// },
9236 /// "MimeType": {
9237 /// "description": "MIME type where available.",
9238 /// "type": "string"
9239 /// },
9240 /// "ModTime": {
9241 /// "description": "Modification timestamp in RFC3339 format.",
9242 /// "type": "string"
9243 /// },
9244 /// "Name": {
9245 /// "description": "Base name of the entry.",
9246 /// "type": "string"
9247 /// },
9248 /// "OrigID": {
9249 /// "description": "Original backend identifier when recorded.",
9250 /// "type": "string"
9251 /// },
9252 /// "Path": {
9253 /// "description": "Path relative to the remote root.",
9254 /// "type": "string"
9255 /// },
9256 /// "Size": {
9257 /// "description": "Object size in bytes.",
9258 /// "type": "number"
9259 /// },
9260 /// "Tier": {
9261 /// "description": "Storage class or tier, if supplied by the
9262 /// backend.",
9263 /// "type": "string"
9264 /// }
9265 /// }
9266 /// }
9267 /// }
9268 ///}
9269 /// ```
9270 /// </details>
9271 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9272 pub struct OperationsStatResponse {
9273 pub item: ::std::option::Option<OperationsStatResponseItem>,
9274 }
9275
9276 impl ::std::convert::From<&OperationsStatResponse> for OperationsStatResponse {
9277 fn from(value: &OperationsStatResponse) -> Self {
9278 value.clone()
9279 }
9280 }
9281
9282 ///`OperationsStatResponseItem`
9283 ///
9284 /// <details><summary>JSON schema</summary>
9285 ///
9286 /// ```json
9287 ///{
9288 /// "type": "object",
9289 /// "required": [
9290 /// "IsDir",
9291 /// "MimeType",
9292 /// "ModTime",
9293 /// "Name",
9294 /// "Path",
9295 /// "Size"
9296 /// ],
9297 /// "properties": {
9298 /// "Encrypted": {
9299 /// "description": "Encrypted entry name when using crypt remotes.",
9300 /// "type": "string"
9301 /// },
9302 /// "EncryptedPath": {
9303 /// "description": "Encrypted path when using crypt remotes.",
9304 /// "type": "string"
9305 /// },
9306 /// "Hashes": {
9307 /// "description": "Hash digests keyed by algorithm when requested.",
9308 /// "type": "object",
9309 /// "additionalProperties": {
9310 /// "type": "string"
9311 /// }
9312 /// },
9313 /// "ID": {
9314 /// "description": "Backend-specific identifier when provided.",
9315 /// "type": "string"
9316 /// },
9317 /// "IsBucket": {
9318 /// "description": "True for bucket/root entries on bucket-based
9319 /// remotes.",
9320 /// "type": "boolean"
9321 /// },
9322 /// "IsDir": {
9323 /// "description": "True if the entry is a directory.",
9324 /// "type": "boolean"
9325 /// },
9326 /// "Metadata": {
9327 /// "description": "Backend-provided metadata map.",
9328 /// "type": "object",
9329 /// "additionalProperties": {}
9330 /// },
9331 /// "MimeType": {
9332 /// "description": "MIME type where available.",
9333 /// "type": "string"
9334 /// },
9335 /// "ModTime": {
9336 /// "description": "Modification timestamp in RFC3339 format.",
9337 /// "type": "string"
9338 /// },
9339 /// "Name": {
9340 /// "description": "Base name of the entry.",
9341 /// "type": "string"
9342 /// },
9343 /// "OrigID": {
9344 /// "description": "Original backend identifier when recorded.",
9345 /// "type": "string"
9346 /// },
9347 /// "Path": {
9348 /// "description": "Path relative to the remote root.",
9349 /// "type": "string"
9350 /// },
9351 /// "Size": {
9352 /// "description": "Object size in bytes.",
9353 /// "type": "number"
9354 /// },
9355 /// "Tier": {
9356 /// "description": "Storage class or tier, if supplied by the
9357 /// backend.",
9358 /// "type": "string"
9359 /// }
9360 /// }
9361 ///}
9362 /// ```
9363 /// </details>
9364 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9365 pub struct OperationsStatResponseItem {
9366 ///Encrypted entry name when using crypt remotes.
9367 #[serde(
9368 rename = "Encrypted",
9369 default,
9370 skip_serializing_if = "::std::option::Option::is_none"
9371 )]
9372 pub encrypted: ::std::option::Option<::std::string::String>,
9373 ///Encrypted path when using crypt remotes.
9374 #[serde(
9375 rename = "EncryptedPath",
9376 default,
9377 skip_serializing_if = "::std::option::Option::is_none"
9378 )]
9379 pub encrypted_path: ::std::option::Option<::std::string::String>,
9380 ///Hash digests keyed by algorithm when requested.
9381 #[serde(
9382 rename = "Hashes",
9383 default,
9384 skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
9385 )]
9386 pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
9387 ///Backend-specific identifier when provided.
9388 #[serde(
9389 rename = "ID",
9390 default,
9391 skip_serializing_if = "::std::option::Option::is_none"
9392 )]
9393 pub id: ::std::option::Option<::std::string::String>,
9394 ///True for bucket/root entries on bucket-based remotes.
9395 #[serde(
9396 rename = "IsBucket",
9397 default,
9398 skip_serializing_if = "::std::option::Option::is_none"
9399 )]
9400 pub is_bucket: ::std::option::Option<bool>,
9401 ///True if the entry is a directory.
9402 #[serde(rename = "IsDir")]
9403 pub is_dir: bool,
9404 ///Backend-provided metadata map.
9405 #[serde(
9406 rename = "Metadata",
9407 default,
9408 skip_serializing_if = "::serde_json::Map::is_empty"
9409 )]
9410 pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9411 ///MIME type where available.
9412 #[serde(rename = "MimeType")]
9413 pub mime_type: ::std::string::String,
9414 ///Modification timestamp in RFC3339 format.
9415 #[serde(rename = "ModTime")]
9416 pub mod_time: ::std::string::String,
9417 ///Base name of the entry.
9418 #[serde(rename = "Name")]
9419 pub name: ::std::string::String,
9420 ///Original backend identifier when recorded.
9421 #[serde(
9422 rename = "OrigID",
9423 default,
9424 skip_serializing_if = "::std::option::Option::is_none"
9425 )]
9426 pub orig_id: ::std::option::Option<::std::string::String>,
9427 ///Path relative to the remote root.
9428 #[serde(rename = "Path")]
9429 pub path: ::std::string::String,
9430 #[serde(rename = "Size")]
9431 pub size: f64,
9432 ///Storage class or tier, if supplied by the backend.
9433 #[serde(
9434 rename = "Tier",
9435 default,
9436 skip_serializing_if = "::std::option::Option::is_none"
9437 )]
9438 pub tier: ::std::option::Option<::std::string::String>,
9439 }
9440
9441 impl ::std::convert::From<&OperationsStatResponseItem> for OperationsStatResponseItem {
9442 fn from(value: &OperationsStatResponseItem) -> Self {
9443 value.clone()
9444 }
9445 }
9446
9447 ///`OperationsUploadfileResponse`
9448 ///
9449 /// <details><summary>JSON schema</summary>
9450 ///
9451 /// ```json
9452 ///{
9453 /// "type": "object",
9454 /// "properties": {
9455 /// "jobid": {
9456 /// "description": "Job ID returned when _async=true.",
9457 /// "type": "integer"
9458 /// }
9459 /// },
9460 /// "additionalProperties": true
9461 ///}
9462 /// ```
9463 /// </details>
9464 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9465 pub struct OperationsUploadfileResponse {
9466 ///Job ID returned when _async=true.
9467 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9468 pub jobid: ::std::option::Option<i64>,
9469 }
9470
9471 impl ::std::convert::From<&OperationsUploadfileResponse> for OperationsUploadfileResponse {
9472 fn from(value: &OperationsUploadfileResponse) -> Self {
9473 value.clone()
9474 }
9475 }
9476
9477 impl ::std::default::Default for OperationsUploadfileResponse {
9478 fn default() -> Self {
9479 Self {
9480 jobid: Default::default(),
9481 }
9482 }
9483 }
9484
9485 ///`OptionsBlocksRequest`
9486 ///
9487 /// <details><summary>JSON schema</summary>
9488 ///
9489 /// ```json
9490 ///{
9491 /// "type": "object",
9492 /// "properties": {
9493 /// "_async": {
9494 /// "description": "Run the command asynchronously. Returns a job id
9495 /// immediately.",
9496 /// "type": "boolean"
9497 /// },
9498 /// "_group": {
9499 /// "description": "Assign the request to a custom stats group.",
9500 /// "type": "string"
9501 /// }
9502 /// }
9503 ///}
9504 /// ```
9505 /// </details>
9506 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9507 pub struct OptionsBlocksRequest {
9508 ///Run the command asynchronously. Returns a job id immediately.
9509 #[serde(
9510 rename = "_async",
9511 default,
9512 skip_serializing_if = "::std::option::Option::is_none"
9513 )]
9514 pub async_: ::std::option::Option<bool>,
9515 ///Assign the request to a custom stats group.
9516 #[serde(
9517 rename = "_group",
9518 default,
9519 skip_serializing_if = "::std::option::Option::is_none"
9520 )]
9521 pub group: ::std::option::Option<::std::string::String>,
9522 }
9523
9524 impl ::std::convert::From<&OptionsBlocksRequest> for OptionsBlocksRequest {
9525 fn from(value: &OptionsBlocksRequest) -> Self {
9526 value.clone()
9527 }
9528 }
9529
9530 impl ::std::default::Default for OptionsBlocksRequest {
9531 fn default() -> Self {
9532 Self {
9533 async_: Default::default(),
9534 group: Default::default(),
9535 }
9536 }
9537 }
9538
9539 ///`OptionsBlocksResponse`
9540 ///
9541 /// <details><summary>JSON schema</summary>
9542 ///
9543 /// ```json
9544 ///{
9545 /// "type": "object",
9546 /// "required": [
9547 /// "options"
9548 /// ],
9549 /// "properties": {
9550 /// "options": {
9551 /// "type": "array",
9552 /// "items": {
9553 /// "type": "string"
9554 /// }
9555 /// }
9556 /// }
9557 ///}
9558 /// ```
9559 /// </details>
9560 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9561 pub struct OptionsBlocksResponse {
9562 pub options: ::std::vec::Vec<::std::string::String>,
9563 }
9564
9565 impl ::std::convert::From<&OptionsBlocksResponse> for OptionsBlocksResponse {
9566 fn from(value: &OptionsBlocksResponse) -> Self {
9567 value.clone()
9568 }
9569 }
9570
9571 ///`OptionsGetRequest`
9572 ///
9573 /// <details><summary>JSON schema</summary>
9574 ///
9575 /// ```json
9576 ///{
9577 /// "type": "object",
9578 /// "properties": {
9579 /// "_async": {
9580 /// "description": "Run the command asynchronously. Returns a job id
9581 /// immediately.",
9582 /// "type": "boolean"
9583 /// },
9584 /// "_group": {
9585 /// "description": "Assign the request to a custom stats group.",
9586 /// "type": "string"
9587 /// },
9588 /// "blocks": {
9589 /// "description": "Optional comma-separated list of option block names
9590 /// to return.",
9591 /// "type": "string"
9592 /// }
9593 /// }
9594 ///}
9595 /// ```
9596 /// </details>
9597 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9598 pub struct OptionsGetRequest {
9599 ///Run the command asynchronously. Returns a job id immediately.
9600 #[serde(
9601 rename = "_async",
9602 default,
9603 skip_serializing_if = "::std::option::Option::is_none"
9604 )]
9605 pub async_: ::std::option::Option<bool>,
9606 ///Optional comma-separated list of option block names to return.
9607 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9608 pub blocks: ::std::option::Option<::std::string::String>,
9609 ///Assign the request to a custom stats group.
9610 #[serde(
9611 rename = "_group",
9612 default,
9613 skip_serializing_if = "::std::option::Option::is_none"
9614 )]
9615 pub group: ::std::option::Option<::std::string::String>,
9616 }
9617
9618 impl ::std::convert::From<&OptionsGetRequest> for OptionsGetRequest {
9619 fn from(value: &OptionsGetRequest) -> Self {
9620 value.clone()
9621 }
9622 }
9623
9624 impl ::std::default::Default for OptionsGetRequest {
9625 fn default() -> Self {
9626 Self {
9627 async_: Default::default(),
9628 blocks: Default::default(),
9629 group: Default::default(),
9630 }
9631 }
9632 }
9633
9634 ///`OptionsGetResponse`
9635 ///
9636 /// <details><summary>JSON schema</summary>
9637 ///
9638 /// ```json
9639 ///{
9640 /// "type": "object",
9641 /// "required": [
9642 /// "dlna",
9643 /// "filter",
9644 /// "ftp",
9645 /// "http",
9646 /// "log",
9647 /// "main",
9648 /// "mount",
9649 /// "nfs",
9650 /// "proxy",
9651 /// "rc",
9652 /// "restic",
9653 /// "s3",
9654 /// "sftp",
9655 /// "vfs",
9656 /// "webdav"
9657 /// ],
9658 /// "properties": {
9659 /// "dlna": {
9660 /// "type": "object",
9661 /// "additionalProperties": true
9662 /// },
9663 /// "filter": {
9664 /// "type": "object",
9665 /// "additionalProperties": true
9666 /// },
9667 /// "ftp": {
9668 /// "type": "object",
9669 /// "additionalProperties": true
9670 /// },
9671 /// "http": {
9672 /// "type": "object",
9673 /// "additionalProperties": true
9674 /// },
9675 /// "log": {
9676 /// "type": "object",
9677 /// "additionalProperties": true
9678 /// },
9679 /// "main": {
9680 /// "type": "object",
9681 /// "additionalProperties": true
9682 /// },
9683 /// "mount": {
9684 /// "type": "object",
9685 /// "additionalProperties": true
9686 /// },
9687 /// "nfs": {
9688 /// "type": "object",
9689 /// "additionalProperties": true
9690 /// },
9691 /// "proxy": {
9692 /// "type": "object",
9693 /// "additionalProperties": true
9694 /// },
9695 /// "rc": {
9696 /// "type": "object",
9697 /// "additionalProperties": true
9698 /// },
9699 /// "restic": {
9700 /// "type": "object",
9701 /// "additionalProperties": true
9702 /// },
9703 /// "s3": {
9704 /// "type": "object",
9705 /// "additionalProperties": true
9706 /// },
9707 /// "sftp": {
9708 /// "type": "object",
9709 /// "additionalProperties": true
9710 /// },
9711 /// "vfs": {
9712 /// "type": "object",
9713 /// "additionalProperties": true
9714 /// },
9715 /// "webdav": {
9716 /// "type": "object",
9717 /// "additionalProperties": true
9718 /// }
9719 /// },
9720 /// "additionalProperties": true
9721 ///}
9722 /// ```
9723 /// </details>
9724 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9725 pub struct OptionsGetResponse {
9726 pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9727 pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9728 pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9729 pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9730 pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9731 pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9732 pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9733 pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9734 pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9735 pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9736 pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9737 pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9738 pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9739 pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9740 pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
9741 }
9742
9743 impl ::std::convert::From<&OptionsGetResponse> for OptionsGetResponse {
9744 fn from(value: &OptionsGetResponse) -> Self {
9745 value.clone()
9746 }
9747 }
9748
9749 ///`OptionsInfoOption`
9750 ///
9751 /// <details><summary>JSON schema</summary>
9752 ///
9753 /// ```json
9754 ///{
9755 /// "type": "object",
9756 /// "required": [
9757 /// "Advanced",
9758 /// "Default",
9759 /// "DefaultStr",
9760 /// "Exclusive",
9761 /// "FieldName",
9762 /// "Help",
9763 /// "Hide",
9764 /// "IsPassword",
9765 /// "Name",
9766 /// "NoPrefix",
9767 /// "Required",
9768 /// "Sensitive",
9769 /// "Type",
9770 /// "Value",
9771 /// "ValueStr"
9772 /// ],
9773 /// "properties": {
9774 /// "Advanced": {
9775 /// "type": "boolean"
9776 /// },
9777 /// "Default": {
9778 /// "description": "Default value for this option.",
9779 /// "anyOf": [
9780 /// {
9781 /// "type": "array",
9782 /// "items": {
9783 /// "type": "string"
9784 /// }
9785 /// },
9786 /// {
9787 /// "type": "boolean"
9788 /// },
9789 /// {
9790 /// "type": "number"
9791 /// },
9792 /// {
9793 /// "type": "string"
9794 /// },
9795 /// {
9796 /// "type": "object",
9797 /// "required": [
9798 /// "Valid",
9799 /// "Value"
9800 /// ],
9801 /// "properties": {
9802 /// "Valid": {
9803 /// "type": "boolean"
9804 /// },
9805 /// "Value": {
9806 /// "type": "boolean"
9807 /// }
9808 /// },
9809 /// "additionalProperties": false
9810 /// }
9811 /// ]
9812 /// },
9813 /// "DefaultStr": {
9814 /// "type": "string"
9815 /// },
9816 /// "Examples": {
9817 /// "type": "array",
9818 /// "items": {
9819 /// "$ref": "#/components/schemas/OptionsInfoOptionExample"
9820 /// }
9821 /// },
9822 /// "Exclusive": {
9823 /// "type": "boolean"
9824 /// },
9825 /// "FieldName": {
9826 /// "type": "string"
9827 /// },
9828 /// "Groups": {
9829 /// "type": "string"
9830 /// },
9831 /// "Help": {
9832 /// "type": "string"
9833 /// },
9834 /// "Hide": {
9835 /// "type": "integer"
9836 /// },
9837 /// "IsPassword": {
9838 /// "type": "boolean"
9839 /// },
9840 /// "Name": {
9841 /// "type": "string"
9842 /// },
9843 /// "NoPrefix": {
9844 /// "type": "boolean"
9845 /// },
9846 /// "Required": {
9847 /// "type": "boolean"
9848 /// },
9849 /// "Sensitive": {
9850 /// "type": "boolean"
9851 /// },
9852 /// "ShortOpt": {
9853 /// "type": "string"
9854 /// },
9855 /// "Type": {
9856 /// "type": "string"
9857 /// },
9858 /// "Value": {
9859 /// "oneOf": [
9860 /// {
9861 /// "type": "null"
9862 /// },
9863 /// {
9864 /// "anyOf": [
9865 /// {
9866 /// "type": "boolean"
9867 /// },
9868 /// {
9869 /// "type": "number"
9870 /// }
9871 /// ]
9872 /// }
9873 /// ]
9874 /// },
9875 /// "ValueStr": {
9876 /// "type": "string"
9877 /// }
9878 /// },
9879 /// "additionalProperties": true
9880 ///}
9881 /// ```
9882 /// </details>
9883 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9884 pub struct OptionsInfoOption {
9885 #[serde(rename = "Advanced")]
9886 pub advanced: bool,
9887 ///Default value for this option.
9888 #[serde(rename = "Default")]
9889 pub default: OptionsInfoOptionDefault,
9890 #[serde(rename = "DefaultStr")]
9891 pub default_str: ::std::string::String,
9892 #[serde(
9893 rename = "Examples",
9894 default,
9895 skip_serializing_if = "::std::vec::Vec::is_empty"
9896 )]
9897 pub examples: ::std::vec::Vec<OptionsInfoOptionExample>,
9898 #[serde(rename = "Exclusive")]
9899 pub exclusive: bool,
9900 #[serde(rename = "FieldName")]
9901 pub field_name: ::std::string::String,
9902 #[serde(
9903 rename = "Groups",
9904 default,
9905 skip_serializing_if = "::std::option::Option::is_none"
9906 )]
9907 pub groups: ::std::option::Option<::std::string::String>,
9908 #[serde(rename = "Help")]
9909 pub help: ::std::string::String,
9910 #[serde(rename = "Hide")]
9911 pub hide: i64,
9912 #[serde(rename = "IsPassword")]
9913 pub is_password: bool,
9914 #[serde(rename = "Name")]
9915 pub name: ::std::string::String,
9916 #[serde(rename = "NoPrefix")]
9917 pub no_prefix: bool,
9918 #[serde(rename = "Required")]
9919 pub required: bool,
9920 #[serde(rename = "Sensitive")]
9921 pub sensitive: bool,
9922 #[serde(
9923 rename = "ShortOpt",
9924 default,
9925 skip_serializing_if = "::std::option::Option::is_none"
9926 )]
9927 pub short_opt: ::std::option::Option<::std::string::String>,
9928 #[serde(rename = "Type")]
9929 pub type_: ::std::string::String,
9930 #[serde(rename = "Value")]
9931 pub value: ::std::option::Option<OptionsInfoOptionValue>,
9932 #[serde(rename = "ValueStr")]
9933 pub value_str: ::std::string::String,
9934 }
9935
9936 impl ::std::convert::From<&OptionsInfoOption> for OptionsInfoOption {
9937 fn from(value: &OptionsInfoOption) -> Self {
9938 value.clone()
9939 }
9940 }
9941
9942 ///Default value for this option.
9943 ///
9944 /// <details><summary>JSON schema</summary>
9945 ///
9946 /// ```json
9947 ///{
9948 /// "description": "Default value for this option.",
9949 /// "anyOf": [
9950 /// {
9951 /// "type": "array",
9952 /// "items": {
9953 /// "type": "string"
9954 /// }
9955 /// },
9956 /// {
9957 /// "type": "boolean"
9958 /// },
9959 /// {
9960 /// "type": "number"
9961 /// },
9962 /// {
9963 /// "type": "string"
9964 /// },
9965 /// {
9966 /// "type": "object",
9967 /// "required": [
9968 /// "Valid",
9969 /// "Value"
9970 /// ],
9971 /// "properties": {
9972 /// "Valid": {
9973 /// "type": "boolean"
9974 /// },
9975 /// "Value": {
9976 /// "type": "boolean"
9977 /// }
9978 /// },
9979 /// "additionalProperties": false
9980 /// }
9981 /// ]
9982 ///}
9983 /// ```
9984 /// </details>
9985 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9986 #[serde(untagged, deny_unknown_fields)]
9987 pub enum OptionsInfoOptionDefault {
9988 Variant0(::std::vec::Vec<::std::string::String>),
9989 Variant1(bool),
9990 Variant2(f64),
9991 Variant3(::std::string::String),
9992 Variant4 {
9993 #[serde(rename = "Valid")]
9994 valid: bool,
9995 #[serde(rename = "Value")]
9996 value: bool,
9997 },
9998 }
9999
10000 impl ::std::convert::From<&Self> for OptionsInfoOptionDefault {
10001 fn from(value: &OptionsInfoOptionDefault) -> Self {
10002 value.clone()
10003 }
10004 }
10005
10006 impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionDefault {
10007 fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
10008 Self::Variant0(value)
10009 }
10010 }
10011
10012 impl ::std::convert::From<bool> for OptionsInfoOptionDefault {
10013 fn from(value: bool) -> Self {
10014 Self::Variant1(value)
10015 }
10016 }
10017
10018 impl ::std::convert::From<f64> for OptionsInfoOptionDefault {
10019 fn from(value: f64) -> Self {
10020 Self::Variant2(value)
10021 }
10022 }
10023
10024 ///`OptionsInfoOptionExample`
10025 ///
10026 /// <details><summary>JSON schema</summary>
10027 ///
10028 /// ```json
10029 ///{
10030 /// "type": "object",
10031 /// "required": [
10032 /// "Help",
10033 /// "Value"
10034 /// ],
10035 /// "properties": {
10036 /// "Help": {
10037 /// "type": "string"
10038 /// },
10039 /// "Value": {
10040 /// "type": "string"
10041 /// }
10042 /// },
10043 /// "additionalProperties": true
10044 ///}
10045 /// ```
10046 /// </details>
10047 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10048 pub struct OptionsInfoOptionExample {
10049 #[serde(rename = "Help")]
10050 pub help: ::std::string::String,
10051 #[serde(rename = "Value")]
10052 pub value: ::std::string::String,
10053 }
10054
10055 impl ::std::convert::From<&OptionsInfoOptionExample> for OptionsInfoOptionExample {
10056 fn from(value: &OptionsInfoOptionExample) -> Self {
10057 value.clone()
10058 }
10059 }
10060
10061 ///`OptionsInfoOptionValue`
10062 ///
10063 /// <details><summary>JSON schema</summary>
10064 ///
10065 /// ```json
10066 ///{
10067 /// "anyOf": [
10068 /// {
10069 /// "type": "boolean"
10070 /// },
10071 /// {
10072 /// "type": "number"
10073 /// }
10074 /// ]
10075 ///}
10076 /// ```
10077 /// </details>
10078 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10079 #[serde(untagged)]
10080 pub enum OptionsInfoOptionValue {
10081 Variant0(bool),
10082 Variant1(f64),
10083 }
10084
10085 impl ::std::convert::From<&Self> for OptionsInfoOptionValue {
10086 fn from(value: &OptionsInfoOptionValue) -> Self {
10087 value.clone()
10088 }
10089 }
10090
10091 impl ::std::str::FromStr for OptionsInfoOptionValue {
10092 type Err = self::error::ConversionError;
10093 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10094 if let Ok(v) = value.parse() {
10095 Ok(Self::Variant0(v))
10096 } else if let Ok(v) = value.parse() {
10097 Ok(Self::Variant1(v))
10098 } else {
10099 Err("string conversion failed for all variants".into())
10100 }
10101 }
10102 }
10103
10104 impl ::std::convert::TryFrom<&str> for OptionsInfoOptionValue {
10105 type Error = self::error::ConversionError;
10106 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10107 value.parse()
10108 }
10109 }
10110
10111 impl ::std::convert::TryFrom<&::std::string::String> for OptionsInfoOptionValue {
10112 type Error = self::error::ConversionError;
10113 fn try_from(
10114 value: &::std::string::String,
10115 ) -> ::std::result::Result<Self, self::error::ConversionError> {
10116 value.parse()
10117 }
10118 }
10119
10120 impl ::std::convert::TryFrom<::std::string::String> for OptionsInfoOptionValue {
10121 type Error = self::error::ConversionError;
10122 fn try_from(
10123 value: ::std::string::String,
10124 ) -> ::std::result::Result<Self, self::error::ConversionError> {
10125 value.parse()
10126 }
10127 }
10128
10129 impl ::std::fmt::Display for OptionsInfoOptionValue {
10130 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10131 match self {
10132 Self::Variant0(x) => x.fmt(f),
10133 Self::Variant1(x) => x.fmt(f),
10134 }
10135 }
10136 }
10137
10138 impl ::std::convert::From<bool> for OptionsInfoOptionValue {
10139 fn from(value: bool) -> Self {
10140 Self::Variant0(value)
10141 }
10142 }
10143
10144 impl ::std::convert::From<f64> for OptionsInfoOptionValue {
10145 fn from(value: f64) -> Self {
10146 Self::Variant1(value)
10147 }
10148 }
10149
10150 ///`OptionsInfoRequest`
10151 ///
10152 /// <details><summary>JSON schema</summary>
10153 ///
10154 /// ```json
10155 ///{
10156 /// "type": "object",
10157 /// "properties": {
10158 /// "_async": {
10159 /// "description": "Run the command asynchronously. Returns a job id
10160 /// immediately.",
10161 /// "type": "boolean"
10162 /// },
10163 /// "_group": {
10164 /// "description": "Assign the request to a custom stats group.",
10165 /// "type": "string"
10166 /// },
10167 /// "blocks": {
10168 /// "description": "Optional comma-separated list of option block names
10169 /// to describe.",
10170 /// "type": "string"
10171 /// }
10172 /// }
10173 ///}
10174 /// ```
10175 /// </details>
10176 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10177 pub struct OptionsInfoRequest {
10178 ///Run the command asynchronously. Returns a job id immediately.
10179 #[serde(
10180 rename = "_async",
10181 default,
10182 skip_serializing_if = "::std::option::Option::is_none"
10183 )]
10184 pub async_: ::std::option::Option<bool>,
10185 ///Optional comma-separated list of option block names to describe.
10186 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10187 pub blocks: ::std::option::Option<::std::string::String>,
10188 ///Assign the request to a custom stats group.
10189 #[serde(
10190 rename = "_group",
10191 default,
10192 skip_serializing_if = "::std::option::Option::is_none"
10193 )]
10194 pub group: ::std::option::Option<::std::string::String>,
10195 }
10196
10197 impl ::std::convert::From<&OptionsInfoRequest> for OptionsInfoRequest {
10198 fn from(value: &OptionsInfoRequest) -> Self {
10199 value.clone()
10200 }
10201 }
10202
10203 impl ::std::default::Default for OptionsInfoRequest {
10204 fn default() -> Self {
10205 Self {
10206 async_: Default::default(),
10207 blocks: Default::default(),
10208 group: Default::default(),
10209 }
10210 }
10211 }
10212
10213 ///`OptionsInfoResponse`
10214 ///
10215 /// <details><summary>JSON schema</summary>
10216 ///
10217 /// ```json
10218 ///{
10219 /// "type": "object",
10220 /// "required": [
10221 /// "dlna",
10222 /// "filter",
10223 /// "ftp",
10224 /// "http",
10225 /// "log",
10226 /// "main",
10227 /// "mount",
10228 /// "nfs",
10229 /// "proxy",
10230 /// "rc",
10231 /// "restic",
10232 /// "s3",
10233 /// "sftp",
10234 /// "vfs",
10235 /// "webdav"
10236 /// ],
10237 /// "properties": {
10238 /// "dlna": {
10239 /// "type": "array",
10240 /// "items": {
10241 /// "$ref": "#/components/schemas/OptionsInfoOption"
10242 /// }
10243 /// },
10244 /// "filter": {
10245 /// "type": "array",
10246 /// "items": {
10247 /// "$ref": "#/components/schemas/OptionsInfoOption"
10248 /// }
10249 /// },
10250 /// "ftp": {
10251 /// "type": "array",
10252 /// "items": {
10253 /// "$ref": "#/components/schemas/OptionsInfoOption"
10254 /// }
10255 /// },
10256 /// "http": {
10257 /// "type": "array",
10258 /// "items": {
10259 /// "$ref": "#/components/schemas/OptionsInfoOption"
10260 /// }
10261 /// },
10262 /// "log": {
10263 /// "type": "array",
10264 /// "items": {
10265 /// "$ref": "#/components/schemas/OptionsInfoOption"
10266 /// }
10267 /// },
10268 /// "main": {
10269 /// "type": "array",
10270 /// "items": {
10271 /// "$ref": "#/components/schemas/OptionsInfoOption"
10272 /// }
10273 /// },
10274 /// "mount": {
10275 /// "type": "array",
10276 /// "items": {
10277 /// "$ref": "#/components/schemas/OptionsInfoOption"
10278 /// }
10279 /// },
10280 /// "nfs": {
10281 /// "type": "array",
10282 /// "items": {
10283 /// "$ref": "#/components/schemas/OptionsInfoOption"
10284 /// }
10285 /// },
10286 /// "proxy": {
10287 /// "type": "array",
10288 /// "items": {
10289 /// "$ref": "#/components/schemas/OptionsInfoOption"
10290 /// }
10291 /// },
10292 /// "rc": {
10293 /// "type": "array",
10294 /// "items": {
10295 /// "$ref": "#/components/schemas/OptionsInfoOption"
10296 /// }
10297 /// },
10298 /// "restic": {
10299 /// "type": "array",
10300 /// "items": {
10301 /// "$ref": "#/components/schemas/OptionsInfoOption"
10302 /// }
10303 /// },
10304 /// "s3": {
10305 /// "type": "array",
10306 /// "items": {
10307 /// "$ref": "#/components/schemas/OptionsInfoOption"
10308 /// }
10309 /// },
10310 /// "sftp": {
10311 /// "type": "array",
10312 /// "items": {
10313 /// "$ref": "#/components/schemas/OptionsInfoOption"
10314 /// }
10315 /// },
10316 /// "vfs": {
10317 /// "type": "array",
10318 /// "items": {
10319 /// "$ref": "#/components/schemas/OptionsInfoOption"
10320 /// }
10321 /// },
10322 /// "webdav": {
10323 /// "type": "array",
10324 /// "items": {
10325 /// "$ref": "#/components/schemas/OptionsInfoOption"
10326 /// }
10327 /// }
10328 /// },
10329 /// "additionalProperties": {
10330 /// "type": "array",
10331 /// "items": {
10332 /// "$ref": "#/components/schemas/OptionsInfoOption"
10333 /// }
10334 /// }
10335 ///}
10336 /// ```
10337 /// </details>
10338 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10339 pub struct OptionsInfoResponse {
10340 pub dlna: ::std::vec::Vec<OptionsInfoOption>,
10341 pub filter: ::std::vec::Vec<OptionsInfoOption>,
10342 pub ftp: ::std::vec::Vec<OptionsInfoOption>,
10343 pub http: ::std::vec::Vec<OptionsInfoOption>,
10344 pub log: ::std::vec::Vec<OptionsInfoOption>,
10345 pub main: ::std::vec::Vec<OptionsInfoOption>,
10346 pub mount: ::std::vec::Vec<OptionsInfoOption>,
10347 pub nfs: ::std::vec::Vec<OptionsInfoOption>,
10348 pub proxy: ::std::vec::Vec<OptionsInfoOption>,
10349 pub rc: ::std::vec::Vec<OptionsInfoOption>,
10350 pub restic: ::std::vec::Vec<OptionsInfoOption>,
10351 pub s3: ::std::vec::Vec<OptionsInfoOption>,
10352 pub sftp: ::std::vec::Vec<OptionsInfoOption>,
10353 pub vfs: ::std::vec::Vec<OptionsInfoOption>,
10354 pub webdav: ::std::vec::Vec<OptionsInfoOption>,
10355 #[serde(flatten)]
10356 pub extra:
10357 ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<OptionsInfoOption>>,
10358 }
10359
10360 impl ::std::convert::From<&OptionsInfoResponse> for OptionsInfoResponse {
10361 fn from(value: &OptionsInfoResponse) -> Self {
10362 value.clone()
10363 }
10364 }
10365
10366 ///`OptionsLocalRequest`
10367 ///
10368 /// <details><summary>JSON schema</summary>
10369 ///
10370 /// ```json
10371 ///{
10372 /// "type": "object",
10373 /// "properties": {
10374 /// "_async": {
10375 /// "description": "Run the command asynchronously. Returns a job id
10376 /// immediately.",
10377 /// "type": "boolean"
10378 /// },
10379 /// "_group": {
10380 /// "description": "Assign the request to a custom stats group.",
10381 /// "type": "string"
10382 /// }
10383 /// }
10384 ///}
10385 /// ```
10386 /// </details>
10387 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10388 pub struct OptionsLocalRequest {
10389 ///Run the command asynchronously. Returns a job id immediately.
10390 #[serde(
10391 rename = "_async",
10392 default,
10393 skip_serializing_if = "::std::option::Option::is_none"
10394 )]
10395 pub async_: ::std::option::Option<bool>,
10396 ///Assign the request to a custom stats group.
10397 #[serde(
10398 rename = "_group",
10399 default,
10400 skip_serializing_if = "::std::option::Option::is_none"
10401 )]
10402 pub group: ::std::option::Option<::std::string::String>,
10403 }
10404
10405 impl ::std::convert::From<&OptionsLocalRequest> for OptionsLocalRequest {
10406 fn from(value: &OptionsLocalRequest) -> Self {
10407 value.clone()
10408 }
10409 }
10410
10411 impl ::std::default::Default for OptionsLocalRequest {
10412 fn default() -> Self {
10413 Self {
10414 async_: Default::default(),
10415 group: Default::default(),
10416 }
10417 }
10418 }
10419
10420 ///`OptionsLocalResponse`
10421 ///
10422 /// <details><summary>JSON schema</summary>
10423 ///
10424 /// ```json
10425 ///{
10426 /// "type": "object",
10427 /// "required": [
10428 /// "config",
10429 /// "filter"
10430 /// ],
10431 /// "properties": {
10432 /// "config": {
10433 /// "type": "object",
10434 /// "required": [
10435 /// "AskPassword",
10436 /// "AutoConfirm",
10437 /// "BackupDir",
10438 /// "BindAddr",
10439 /// "BufferSize",
10440 /// "BwLimit",
10441 /// "BwLimitFile",
10442 /// "CaCert",
10443 /// "CheckFirst",
10444 /// "CheckSum",
10445 /// "Checkers",
10446 /// "ClientCert",
10447 /// "ClientKey",
10448 /// "CompareDest",
10449 /// "ConnectTimeout",
10450 /// "Cookie",
10451 /// "CopyDest",
10452 /// "CutoffMode",
10453 /// "DataRateUnit",
10454 /// "DefaultTime",
10455 /// "DeleteMode",
10456 /// "DisableFeatures",
10457 /// "DisableHTTP2",
10458 /// "DisableHTTPKeepAlives",
10459 /// "DownloadHeaders",
10460 /// "DryRun",
10461 /// "Dump",
10462 /// "ErrorOnNoTransfer",
10463 /// "ExpectContinueTimeout",
10464 /// "FixCase",
10465 /// "FsCacheExpireDuration",
10466 /// "FsCacheExpireInterval",
10467 /// "Headers",
10468 /// "HumanReadable",
10469 /// "IgnoreCaseSync",
10470 /// "IgnoreChecksum",
10471 /// "IgnoreErrors",
10472 /// "IgnoreExisting",
10473 /// "IgnoreSize",
10474 /// "IgnoreTimes",
10475 /// "Immutable",
10476 /// "Inplace",
10477 /// "InsecureSkipVerify",
10478 /// "Interactive",
10479 /// "KvLockTime",
10480 /// "Links",
10481 /// "LogLevel",
10482 /// "LowLevelRetries",
10483 /// "MaxBacklog",
10484 /// "MaxBufferMemory",
10485 /// "MaxDelete",
10486 /// "MaxDeleteSize",
10487 /// "MaxDepth",
10488 /// "MaxDuration",
10489 /// "MaxStatsGroups",
10490 /// "MaxTransfer",
10491 /// "Metadata",
10492 /// "MetadataMapper",
10493 /// "MetadataSet",
10494 /// "ModifyWindow",
10495 /// "MultiThreadChunkSize",
10496 /// "MultiThreadCutoff",
10497 /// "MultiThreadSet",
10498 /// "MultiThreadStreams",
10499 /// "MultiThreadWriteBufferSize",
10500 /// "NoCheckDest",
10501 /// "NoConsole",
10502 /// "NoGzip",
10503 /// "NoTraverse",
10504 /// "NoUnicodeNormalization",
10505 /// "NoUpdateDirModTime",
10506 /// "NoUpdateModTime",
10507 /// "OrderBy",
10508 /// "PartialSuffix",
10509 /// "PasswordCommand",
10510 /// "Progress",
10511 /// "ProgressTerminalTitle",
10512 /// "RefreshTimes",
10513 /// "Retries",
10514 /// "RetriesInterval",
10515 /// "ServerSideAcrossConfigs",
10516 /// "SizeOnly",
10517 /// "StatsFileNameLength",
10518 /// "StatsLogLevel",
10519 /// "StatsOneLine",
10520 /// "StatsOneLineDate",
10521 /// "StatsOneLineDateFormat",
10522 /// "StreamingUploadCutoff",
10523 /// "Suffix",
10524 /// "SuffixKeepExtension",
10525 /// "TPSLimit",
10526 /// "TPSLimitBurst",
10527 /// "TerminalColorMode",
10528 /// "Timeout",
10529 /// "TrackRenames",
10530 /// "TrackRenamesStrategy",
10531 /// "TrafficClass",
10532 /// "Transfers",
10533 /// "UpdateOlder",
10534 /// "UploadHeaders",
10535 /// "UseJSONLog",
10536 /// "UseListR",
10537 /// "UseMmap",
10538 /// "UseServerModTime",
10539 /// "UserAgent"
10540 /// ],
10541 /// "properties": {
10542 /// "AskPassword": {
10543 /// "type": "boolean"
10544 /// },
10545 /// "AutoConfirm": {
10546 /// "type": "boolean"
10547 /// },
10548 /// "BackupDir": {
10549 /// "type": "string"
10550 /// },
10551 /// "BindAddr": {
10552 /// "type": "string"
10553 /// },
10554 /// "BufferSize": {
10555 /// "type": "number"
10556 /// },
10557 /// "BwLimit": {
10558 /// "type": "string"
10559 /// },
10560 /// "BwLimitFile": {
10561 /// "type": "string"
10562 /// },
10563 /// "CaCert": {
10564 /// "type": "array",
10565 /// "items": {
10566 /// "type": "string"
10567 /// }
10568 /// },
10569 /// "CheckFirst": {
10570 /// "type": "boolean"
10571 /// },
10572 /// "CheckSum": {
10573 /// "type": "boolean"
10574 /// },
10575 /// "Checkers": {
10576 /// "type": "number"
10577 /// },
10578 /// "ClientCert": {
10579 /// "type": "string"
10580 /// },
10581 /// "ClientKey": {
10582 /// "type": "string"
10583 /// },
10584 /// "CompareDest": {
10585 /// "type": "array",
10586 /// "items": {
10587 /// "type": "string"
10588 /// }
10589 /// },
10590 /// "ConnectTimeout": {
10591 /// "type": "number"
10592 /// },
10593 /// "Cookie": {
10594 /// "type": "boolean"
10595 /// },
10596 /// "CopyDest": {
10597 /// "type": "array",
10598 /// "items": {
10599 /// "type": "string"
10600 /// }
10601 /// },
10602 /// "CutoffMode": {
10603 /// "type": "string"
10604 /// },
10605 /// "DataRateUnit": {
10606 /// "type": "string"
10607 /// },
10608 /// "DefaultTime": {
10609 /// "type": "string"
10610 /// },
10611 /// "DeleteMode": {
10612 /// "type": "number"
10613 /// },
10614 /// "DisableFeatures": {
10615 /// "type": [
10616 /// "string",
10617 /// "null"
10618 /// ]
10619 /// },
10620 /// "DisableHTTP2": {
10621 /// "type": "boolean"
10622 /// },
10623 /// "DisableHTTPKeepAlives": {
10624 /// "type": "boolean"
10625 /// },
10626 /// "DownloadHeaders": {
10627 /// "type": [
10628 /// "string",
10629 /// "null"
10630 /// ]
10631 /// },
10632 /// "DryRun": {
10633 /// "type": "boolean"
10634 /// },
10635 /// "Dump": {
10636 /// "type": "string"
10637 /// },
10638 /// "ErrorOnNoTransfer": {
10639 /// "type": "boolean"
10640 /// },
10641 /// "ExpectContinueTimeout": {
10642 /// "type": "number"
10643 /// },
10644 /// "FixCase": {
10645 /// "type": "boolean"
10646 /// },
10647 /// "FsCacheExpireDuration": {
10648 /// "type": "number"
10649 /// },
10650 /// "FsCacheExpireInterval": {
10651 /// "type": "number"
10652 /// },
10653 /// "Headers": {
10654 /// "type": [
10655 /// "string",
10656 /// "null"
10657 /// ]
10658 /// },
10659 /// "HumanReadable": {
10660 /// "type": "boolean"
10661 /// },
10662 /// "IgnoreCaseSync": {
10663 /// "type": "boolean"
10664 /// },
10665 /// "IgnoreChecksum": {
10666 /// "type": "boolean"
10667 /// },
10668 /// "IgnoreErrors": {
10669 /// "type": "boolean"
10670 /// },
10671 /// "IgnoreExisting": {
10672 /// "type": "boolean"
10673 /// },
10674 /// "IgnoreSize": {
10675 /// "type": "boolean"
10676 /// },
10677 /// "IgnoreTimes": {
10678 /// "type": "boolean"
10679 /// },
10680 /// "Immutable": {
10681 /// "type": "boolean"
10682 /// },
10683 /// "Inplace": {
10684 /// "type": "boolean"
10685 /// },
10686 /// "InsecureSkipVerify": {
10687 /// "type": "boolean"
10688 /// },
10689 /// "Interactive": {
10690 /// "type": "boolean"
10691 /// },
10692 /// "KvLockTime": {
10693 /// "type": "number"
10694 /// },
10695 /// "Links": {
10696 /// "type": "boolean"
10697 /// },
10698 /// "LogLevel": {
10699 /// "type": "string"
10700 /// },
10701 /// "LowLevelRetries": {
10702 /// "type": "number"
10703 /// },
10704 /// "MaxBacklog": {
10705 /// "type": "number"
10706 /// },
10707 /// "MaxBufferMemory": {
10708 /// "type": "number"
10709 /// },
10710 /// "MaxDelete": {
10711 /// "type": "number"
10712 /// },
10713 /// "MaxDeleteSize": {
10714 /// "type": "number"
10715 /// },
10716 /// "MaxDepth": {
10717 /// "type": "number"
10718 /// },
10719 /// "MaxDuration": {
10720 /// "type": "number"
10721 /// },
10722 /// "MaxStatsGroups": {
10723 /// "type": "number"
10724 /// },
10725 /// "MaxTransfer": {
10726 /// "type": "number"
10727 /// },
10728 /// "Metadata": {
10729 /// "type": "boolean"
10730 /// },
10731 /// "MetadataMapper": {
10732 /// "type": [
10733 /// "string",
10734 /// "null"
10735 /// ]
10736 /// },
10737 /// "MetadataSet": {
10738 /// "type": [
10739 /// "string",
10740 /// "null"
10741 /// ]
10742 /// },
10743 /// "ModifyWindow": {
10744 /// "type": "number"
10745 /// },
10746 /// "MultiThreadChunkSize": {
10747 /// "type": "number"
10748 /// },
10749 /// "MultiThreadCutoff": {
10750 /// "type": "number"
10751 /// },
10752 /// "MultiThreadSet": {
10753 /// "type": "boolean"
10754 /// },
10755 /// "MultiThreadStreams": {
10756 /// "type": "number"
10757 /// },
10758 /// "MultiThreadWriteBufferSize": {
10759 /// "type": "number"
10760 /// },
10761 /// "NoCheckDest": {
10762 /// "type": "boolean"
10763 /// },
10764 /// "NoConsole": {
10765 /// "type": "boolean"
10766 /// },
10767 /// "NoGzip": {
10768 /// "type": "boolean"
10769 /// },
10770 /// "NoTraverse": {
10771 /// "type": "boolean"
10772 /// },
10773 /// "NoUnicodeNormalization": {
10774 /// "type": "boolean"
10775 /// },
10776 /// "NoUpdateDirModTime": {
10777 /// "type": "boolean"
10778 /// },
10779 /// "NoUpdateModTime": {
10780 /// "type": "boolean"
10781 /// },
10782 /// "OrderBy": {
10783 /// "type": "string"
10784 /// },
10785 /// "PartialSuffix": {
10786 /// "type": "string"
10787 /// },
10788 /// "PasswordCommand": {
10789 /// "type": [
10790 /// "string",
10791 /// "null"
10792 /// ]
10793 /// },
10794 /// "Progress": {
10795 /// "type": "boolean"
10796 /// },
10797 /// "ProgressTerminalTitle": {
10798 /// "type": "boolean"
10799 /// },
10800 /// "RefreshTimes": {
10801 /// "type": "boolean"
10802 /// },
10803 /// "Retries": {
10804 /// "type": "number"
10805 /// },
10806 /// "RetriesInterval": {
10807 /// "type": "number"
10808 /// },
10809 /// "ServerSideAcrossConfigs": {
10810 /// "type": "boolean"
10811 /// },
10812 /// "SizeOnly": {
10813 /// "type": "boolean"
10814 /// },
10815 /// "StatsFileNameLength": {
10816 /// "type": "number"
10817 /// },
10818 /// "StatsLogLevel": {
10819 /// "type": "string"
10820 /// },
10821 /// "StatsOneLine": {
10822 /// "type": "boolean"
10823 /// },
10824 /// "StatsOneLineDate": {
10825 /// "type": "boolean"
10826 /// },
10827 /// "StatsOneLineDateFormat": {
10828 /// "type": "string"
10829 /// },
10830 /// "StreamingUploadCutoff": {
10831 /// "type": "number"
10832 /// },
10833 /// "Suffix": {
10834 /// "type": "string"
10835 /// },
10836 /// "SuffixKeepExtension": {
10837 /// "type": "boolean"
10838 /// },
10839 /// "TPSLimit": {
10840 /// "type": "number"
10841 /// },
10842 /// "TPSLimitBurst": {
10843 /// "type": "number"
10844 /// },
10845 /// "TerminalColorMode": {
10846 /// "type": "string"
10847 /// },
10848 /// "Timeout": {
10849 /// "type": "number"
10850 /// },
10851 /// "TrackRenames": {
10852 /// "type": "boolean"
10853 /// },
10854 /// "TrackRenamesStrategy": {
10855 /// "type": "string"
10856 /// },
10857 /// "TrafficClass": {
10858 /// "type": "number"
10859 /// },
10860 /// "Transfers": {
10861 /// "type": "number"
10862 /// },
10863 /// "UpdateOlder": {
10864 /// "type": "boolean"
10865 /// },
10866 /// "UploadHeaders": {
10867 /// "type": [
10868 /// "string",
10869 /// "null"
10870 /// ]
10871 /// },
10872 /// "UseJSONLog": {
10873 /// "type": "boolean"
10874 /// },
10875 /// "UseListR": {
10876 /// "type": "boolean"
10877 /// },
10878 /// "UseMmap": {
10879 /// "type": "boolean"
10880 /// },
10881 /// "UseServerModTime": {
10882 /// "type": "boolean"
10883 /// },
10884 /// "UserAgent": {
10885 /// "type": "string"
10886 /// }
10887 /// }
10888 /// },
10889 /// "filter": {
10890 /// "type": "object",
10891 /// "required": [
10892 /// "DeleteExcluded",
10893 /// "ExcludeFile",
10894 /// "ExcludeFrom",
10895 /// "ExcludeRule",
10896 /// "FilesFrom",
10897 /// "FilesFromRaw",
10898 /// "FilterFrom",
10899 /// "FilterRule",
10900 /// "HashFilter",
10901 /// "IgnoreCase",
10902 /// "IncludeFrom",
10903 /// "IncludeRule",
10904 /// "MaxAge",
10905 /// "MaxSize",
10906 /// "MetaRules",
10907 /// "MinAge",
10908 /// "MinSize"
10909 /// ],
10910 /// "properties": {
10911 /// "DeleteExcluded": {
10912 /// "type": "boolean"
10913 /// },
10914 /// "ExcludeFile": {
10915 /// "type": "array",
10916 /// "items": {
10917 /// "type": "string"
10918 /// }
10919 /// },
10920 /// "ExcludeFrom": {
10921 /// "type": "array",
10922 /// "items": {
10923 /// "type": "string"
10924 /// }
10925 /// },
10926 /// "ExcludeRule": {
10927 /// "type": "array",
10928 /// "items": {
10929 /// "type": "string"
10930 /// }
10931 /// },
10932 /// "FilesFrom": {
10933 /// "type": "array",
10934 /// "items": {
10935 /// "type": "string"
10936 /// }
10937 /// },
10938 /// "FilesFromRaw": {
10939 /// "type": "array",
10940 /// "items": {
10941 /// "type": "string"
10942 /// }
10943 /// },
10944 /// "FilterFrom": {
10945 /// "type": "array",
10946 /// "items": {
10947 /// "type": "string"
10948 /// }
10949 /// },
10950 /// "FilterRule": {
10951 /// "type": "array",
10952 /// "items": {
10953 /// "type": "string"
10954 /// }
10955 /// },
10956 /// "HashFilter": {
10957 /// "type": "string"
10958 /// },
10959 /// "IgnoreCase": {
10960 /// "type": "boolean"
10961 /// },
10962 /// "IncludeFrom": {
10963 /// "type": "array",
10964 /// "items": {
10965 /// "type": "string"
10966 /// }
10967 /// },
10968 /// "IncludeRule": {
10969 /// "type": "array",
10970 /// "items": {
10971 /// "type": "string"
10972 /// }
10973 /// },
10974 /// "MaxAge": {
10975 /// "type": "number"
10976 /// },
10977 /// "MaxSize": {
10978 /// "type": "number"
10979 /// },
10980 /// "MetaRules": {
10981 /// "type": "object",
10982 /// "required": [
10983 /// "ExcludeFrom",
10984 /// "ExcludeRule",
10985 /// "FilterFrom",
10986 /// "FilterRule",
10987 /// "IncludeFrom",
10988 /// "IncludeRule"
10989 /// ],
10990 /// "properties": {
10991 /// "ExcludeFrom": {
10992 /// "type": "array",
10993 /// "items": {
10994 /// "type": "string"
10995 /// }
10996 /// },
10997 /// "ExcludeRule": {
10998 /// "type": "array",
10999 /// "items": {
11000 /// "type": "string"
11001 /// }
11002 /// },
11003 /// "FilterFrom": {
11004 /// "type": "array",
11005 /// "items": {
11006 /// "type": "string"
11007 /// }
11008 /// },
11009 /// "FilterRule": {
11010 /// "type": "array",
11011 /// "items": {
11012 /// "type": "string"
11013 /// }
11014 /// },
11015 /// "IncludeFrom": {
11016 /// "type": "array",
11017 /// "items": {
11018 /// "type": "string"
11019 /// }
11020 /// },
11021 /// "IncludeRule": {
11022 /// "type": "array",
11023 /// "items": {
11024 /// "type": "string"
11025 /// }
11026 /// }
11027 /// }
11028 /// },
11029 /// "MinAge": {
11030 /// "type": "number"
11031 /// },
11032 /// "MinSize": {
11033 /// "type": "number"
11034 /// }
11035 /// }
11036 /// }
11037 /// }
11038 ///}
11039 /// ```
11040 /// </details>
11041 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11042 pub struct OptionsLocalResponse {
11043 pub config: OptionsLocalResponseConfig,
11044 pub filter: OptionsLocalResponseFilter,
11045 }
11046
11047 impl ::std::convert::From<&OptionsLocalResponse> for OptionsLocalResponse {
11048 fn from(value: &OptionsLocalResponse) -> Self {
11049 value.clone()
11050 }
11051 }
11052
11053 ///`OptionsLocalResponseConfig`
11054 ///
11055 /// <details><summary>JSON schema</summary>
11056 ///
11057 /// ```json
11058 ///{
11059 /// "type": "object",
11060 /// "required": [
11061 /// "AskPassword",
11062 /// "AutoConfirm",
11063 /// "BackupDir",
11064 /// "BindAddr",
11065 /// "BufferSize",
11066 /// "BwLimit",
11067 /// "BwLimitFile",
11068 /// "CaCert",
11069 /// "CheckFirst",
11070 /// "CheckSum",
11071 /// "Checkers",
11072 /// "ClientCert",
11073 /// "ClientKey",
11074 /// "CompareDest",
11075 /// "ConnectTimeout",
11076 /// "Cookie",
11077 /// "CopyDest",
11078 /// "CutoffMode",
11079 /// "DataRateUnit",
11080 /// "DefaultTime",
11081 /// "DeleteMode",
11082 /// "DisableFeatures",
11083 /// "DisableHTTP2",
11084 /// "DisableHTTPKeepAlives",
11085 /// "DownloadHeaders",
11086 /// "DryRun",
11087 /// "Dump",
11088 /// "ErrorOnNoTransfer",
11089 /// "ExpectContinueTimeout",
11090 /// "FixCase",
11091 /// "FsCacheExpireDuration",
11092 /// "FsCacheExpireInterval",
11093 /// "Headers",
11094 /// "HumanReadable",
11095 /// "IgnoreCaseSync",
11096 /// "IgnoreChecksum",
11097 /// "IgnoreErrors",
11098 /// "IgnoreExisting",
11099 /// "IgnoreSize",
11100 /// "IgnoreTimes",
11101 /// "Immutable",
11102 /// "Inplace",
11103 /// "InsecureSkipVerify",
11104 /// "Interactive",
11105 /// "KvLockTime",
11106 /// "Links",
11107 /// "LogLevel",
11108 /// "LowLevelRetries",
11109 /// "MaxBacklog",
11110 /// "MaxBufferMemory",
11111 /// "MaxDelete",
11112 /// "MaxDeleteSize",
11113 /// "MaxDepth",
11114 /// "MaxDuration",
11115 /// "MaxStatsGroups",
11116 /// "MaxTransfer",
11117 /// "Metadata",
11118 /// "MetadataMapper",
11119 /// "MetadataSet",
11120 /// "ModifyWindow",
11121 /// "MultiThreadChunkSize",
11122 /// "MultiThreadCutoff",
11123 /// "MultiThreadSet",
11124 /// "MultiThreadStreams",
11125 /// "MultiThreadWriteBufferSize",
11126 /// "NoCheckDest",
11127 /// "NoConsole",
11128 /// "NoGzip",
11129 /// "NoTraverse",
11130 /// "NoUnicodeNormalization",
11131 /// "NoUpdateDirModTime",
11132 /// "NoUpdateModTime",
11133 /// "OrderBy",
11134 /// "PartialSuffix",
11135 /// "PasswordCommand",
11136 /// "Progress",
11137 /// "ProgressTerminalTitle",
11138 /// "RefreshTimes",
11139 /// "Retries",
11140 /// "RetriesInterval",
11141 /// "ServerSideAcrossConfigs",
11142 /// "SizeOnly",
11143 /// "StatsFileNameLength",
11144 /// "StatsLogLevel",
11145 /// "StatsOneLine",
11146 /// "StatsOneLineDate",
11147 /// "StatsOneLineDateFormat",
11148 /// "StreamingUploadCutoff",
11149 /// "Suffix",
11150 /// "SuffixKeepExtension",
11151 /// "TPSLimit",
11152 /// "TPSLimitBurst",
11153 /// "TerminalColorMode",
11154 /// "Timeout",
11155 /// "TrackRenames",
11156 /// "TrackRenamesStrategy",
11157 /// "TrafficClass",
11158 /// "Transfers",
11159 /// "UpdateOlder",
11160 /// "UploadHeaders",
11161 /// "UseJSONLog",
11162 /// "UseListR",
11163 /// "UseMmap",
11164 /// "UseServerModTime",
11165 /// "UserAgent"
11166 /// ],
11167 /// "properties": {
11168 /// "AskPassword": {
11169 /// "type": "boolean"
11170 /// },
11171 /// "AutoConfirm": {
11172 /// "type": "boolean"
11173 /// },
11174 /// "BackupDir": {
11175 /// "type": "string"
11176 /// },
11177 /// "BindAddr": {
11178 /// "type": "string"
11179 /// },
11180 /// "BufferSize": {
11181 /// "type": "number"
11182 /// },
11183 /// "BwLimit": {
11184 /// "type": "string"
11185 /// },
11186 /// "BwLimitFile": {
11187 /// "type": "string"
11188 /// },
11189 /// "CaCert": {
11190 /// "type": "array",
11191 /// "items": {
11192 /// "type": "string"
11193 /// }
11194 /// },
11195 /// "CheckFirst": {
11196 /// "type": "boolean"
11197 /// },
11198 /// "CheckSum": {
11199 /// "type": "boolean"
11200 /// },
11201 /// "Checkers": {
11202 /// "type": "number"
11203 /// },
11204 /// "ClientCert": {
11205 /// "type": "string"
11206 /// },
11207 /// "ClientKey": {
11208 /// "type": "string"
11209 /// },
11210 /// "CompareDest": {
11211 /// "type": "array",
11212 /// "items": {
11213 /// "type": "string"
11214 /// }
11215 /// },
11216 /// "ConnectTimeout": {
11217 /// "type": "number"
11218 /// },
11219 /// "Cookie": {
11220 /// "type": "boolean"
11221 /// },
11222 /// "CopyDest": {
11223 /// "type": "array",
11224 /// "items": {
11225 /// "type": "string"
11226 /// }
11227 /// },
11228 /// "CutoffMode": {
11229 /// "type": "string"
11230 /// },
11231 /// "DataRateUnit": {
11232 /// "type": "string"
11233 /// },
11234 /// "DefaultTime": {
11235 /// "type": "string"
11236 /// },
11237 /// "DeleteMode": {
11238 /// "type": "number"
11239 /// },
11240 /// "DisableFeatures": {
11241 /// "type": [
11242 /// "string",
11243 /// "null"
11244 /// ]
11245 /// },
11246 /// "DisableHTTP2": {
11247 /// "type": "boolean"
11248 /// },
11249 /// "DisableHTTPKeepAlives": {
11250 /// "type": "boolean"
11251 /// },
11252 /// "DownloadHeaders": {
11253 /// "type": [
11254 /// "string",
11255 /// "null"
11256 /// ]
11257 /// },
11258 /// "DryRun": {
11259 /// "type": "boolean"
11260 /// },
11261 /// "Dump": {
11262 /// "type": "string"
11263 /// },
11264 /// "ErrorOnNoTransfer": {
11265 /// "type": "boolean"
11266 /// },
11267 /// "ExpectContinueTimeout": {
11268 /// "type": "number"
11269 /// },
11270 /// "FixCase": {
11271 /// "type": "boolean"
11272 /// },
11273 /// "FsCacheExpireDuration": {
11274 /// "type": "number"
11275 /// },
11276 /// "FsCacheExpireInterval": {
11277 /// "type": "number"
11278 /// },
11279 /// "Headers": {
11280 /// "type": [
11281 /// "string",
11282 /// "null"
11283 /// ]
11284 /// },
11285 /// "HumanReadable": {
11286 /// "type": "boolean"
11287 /// },
11288 /// "IgnoreCaseSync": {
11289 /// "type": "boolean"
11290 /// },
11291 /// "IgnoreChecksum": {
11292 /// "type": "boolean"
11293 /// },
11294 /// "IgnoreErrors": {
11295 /// "type": "boolean"
11296 /// },
11297 /// "IgnoreExisting": {
11298 /// "type": "boolean"
11299 /// },
11300 /// "IgnoreSize": {
11301 /// "type": "boolean"
11302 /// },
11303 /// "IgnoreTimes": {
11304 /// "type": "boolean"
11305 /// },
11306 /// "Immutable": {
11307 /// "type": "boolean"
11308 /// },
11309 /// "Inplace": {
11310 /// "type": "boolean"
11311 /// },
11312 /// "InsecureSkipVerify": {
11313 /// "type": "boolean"
11314 /// },
11315 /// "Interactive": {
11316 /// "type": "boolean"
11317 /// },
11318 /// "KvLockTime": {
11319 /// "type": "number"
11320 /// },
11321 /// "Links": {
11322 /// "type": "boolean"
11323 /// },
11324 /// "LogLevel": {
11325 /// "type": "string"
11326 /// },
11327 /// "LowLevelRetries": {
11328 /// "type": "number"
11329 /// },
11330 /// "MaxBacklog": {
11331 /// "type": "number"
11332 /// },
11333 /// "MaxBufferMemory": {
11334 /// "type": "number"
11335 /// },
11336 /// "MaxDelete": {
11337 /// "type": "number"
11338 /// },
11339 /// "MaxDeleteSize": {
11340 /// "type": "number"
11341 /// },
11342 /// "MaxDepth": {
11343 /// "type": "number"
11344 /// },
11345 /// "MaxDuration": {
11346 /// "type": "number"
11347 /// },
11348 /// "MaxStatsGroups": {
11349 /// "type": "number"
11350 /// },
11351 /// "MaxTransfer": {
11352 /// "type": "number"
11353 /// },
11354 /// "Metadata": {
11355 /// "type": "boolean"
11356 /// },
11357 /// "MetadataMapper": {
11358 /// "type": [
11359 /// "string",
11360 /// "null"
11361 /// ]
11362 /// },
11363 /// "MetadataSet": {
11364 /// "type": [
11365 /// "string",
11366 /// "null"
11367 /// ]
11368 /// },
11369 /// "ModifyWindow": {
11370 /// "type": "number"
11371 /// },
11372 /// "MultiThreadChunkSize": {
11373 /// "type": "number"
11374 /// },
11375 /// "MultiThreadCutoff": {
11376 /// "type": "number"
11377 /// },
11378 /// "MultiThreadSet": {
11379 /// "type": "boolean"
11380 /// },
11381 /// "MultiThreadStreams": {
11382 /// "type": "number"
11383 /// },
11384 /// "MultiThreadWriteBufferSize": {
11385 /// "type": "number"
11386 /// },
11387 /// "NoCheckDest": {
11388 /// "type": "boolean"
11389 /// },
11390 /// "NoConsole": {
11391 /// "type": "boolean"
11392 /// },
11393 /// "NoGzip": {
11394 /// "type": "boolean"
11395 /// },
11396 /// "NoTraverse": {
11397 /// "type": "boolean"
11398 /// },
11399 /// "NoUnicodeNormalization": {
11400 /// "type": "boolean"
11401 /// },
11402 /// "NoUpdateDirModTime": {
11403 /// "type": "boolean"
11404 /// },
11405 /// "NoUpdateModTime": {
11406 /// "type": "boolean"
11407 /// },
11408 /// "OrderBy": {
11409 /// "type": "string"
11410 /// },
11411 /// "PartialSuffix": {
11412 /// "type": "string"
11413 /// },
11414 /// "PasswordCommand": {
11415 /// "type": [
11416 /// "string",
11417 /// "null"
11418 /// ]
11419 /// },
11420 /// "Progress": {
11421 /// "type": "boolean"
11422 /// },
11423 /// "ProgressTerminalTitle": {
11424 /// "type": "boolean"
11425 /// },
11426 /// "RefreshTimes": {
11427 /// "type": "boolean"
11428 /// },
11429 /// "Retries": {
11430 /// "type": "number"
11431 /// },
11432 /// "RetriesInterval": {
11433 /// "type": "number"
11434 /// },
11435 /// "ServerSideAcrossConfigs": {
11436 /// "type": "boolean"
11437 /// },
11438 /// "SizeOnly": {
11439 /// "type": "boolean"
11440 /// },
11441 /// "StatsFileNameLength": {
11442 /// "type": "number"
11443 /// },
11444 /// "StatsLogLevel": {
11445 /// "type": "string"
11446 /// },
11447 /// "StatsOneLine": {
11448 /// "type": "boolean"
11449 /// },
11450 /// "StatsOneLineDate": {
11451 /// "type": "boolean"
11452 /// },
11453 /// "StatsOneLineDateFormat": {
11454 /// "type": "string"
11455 /// },
11456 /// "StreamingUploadCutoff": {
11457 /// "type": "number"
11458 /// },
11459 /// "Suffix": {
11460 /// "type": "string"
11461 /// },
11462 /// "SuffixKeepExtension": {
11463 /// "type": "boolean"
11464 /// },
11465 /// "TPSLimit": {
11466 /// "type": "number"
11467 /// },
11468 /// "TPSLimitBurst": {
11469 /// "type": "number"
11470 /// },
11471 /// "TerminalColorMode": {
11472 /// "type": "string"
11473 /// },
11474 /// "Timeout": {
11475 /// "type": "number"
11476 /// },
11477 /// "TrackRenames": {
11478 /// "type": "boolean"
11479 /// },
11480 /// "TrackRenamesStrategy": {
11481 /// "type": "string"
11482 /// },
11483 /// "TrafficClass": {
11484 /// "type": "number"
11485 /// },
11486 /// "Transfers": {
11487 /// "type": "number"
11488 /// },
11489 /// "UpdateOlder": {
11490 /// "type": "boolean"
11491 /// },
11492 /// "UploadHeaders": {
11493 /// "type": [
11494 /// "string",
11495 /// "null"
11496 /// ]
11497 /// },
11498 /// "UseJSONLog": {
11499 /// "type": "boolean"
11500 /// },
11501 /// "UseListR": {
11502 /// "type": "boolean"
11503 /// },
11504 /// "UseMmap": {
11505 /// "type": "boolean"
11506 /// },
11507 /// "UseServerModTime": {
11508 /// "type": "boolean"
11509 /// },
11510 /// "UserAgent": {
11511 /// "type": "string"
11512 /// }
11513 /// }
11514 ///}
11515 /// ```
11516 /// </details>
11517 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11518 pub struct OptionsLocalResponseConfig {
11519 #[serde(rename = "AskPassword")]
11520 pub ask_password: bool,
11521 #[serde(rename = "AutoConfirm")]
11522 pub auto_confirm: bool,
11523 #[serde(rename = "BackupDir")]
11524 pub backup_dir: ::std::string::String,
11525 #[serde(rename = "BindAddr")]
11526 pub bind_addr: ::std::string::String,
11527 #[serde(rename = "BufferSize")]
11528 pub buffer_size: f64,
11529 #[serde(rename = "BwLimit")]
11530 pub bw_limit: ::std::string::String,
11531 #[serde(rename = "BwLimitFile")]
11532 pub bw_limit_file: ::std::string::String,
11533 #[serde(rename = "CaCert")]
11534 pub ca_cert: ::std::vec::Vec<::std::string::String>,
11535 #[serde(rename = "CheckFirst")]
11536 pub check_first: bool,
11537 #[serde(rename = "CheckSum")]
11538 pub check_sum: bool,
11539 #[serde(rename = "Checkers")]
11540 pub checkers: f64,
11541 #[serde(rename = "ClientCert")]
11542 pub client_cert: ::std::string::String,
11543 #[serde(rename = "ClientKey")]
11544 pub client_key: ::std::string::String,
11545 #[serde(rename = "CompareDest")]
11546 pub compare_dest: ::std::vec::Vec<::std::string::String>,
11547 #[serde(rename = "ConnectTimeout")]
11548 pub connect_timeout: f64,
11549 #[serde(rename = "Cookie")]
11550 pub cookie: bool,
11551 #[serde(rename = "CopyDest")]
11552 pub copy_dest: ::std::vec::Vec<::std::string::String>,
11553 #[serde(rename = "CutoffMode")]
11554 pub cutoff_mode: ::std::string::String,
11555 #[serde(rename = "DataRateUnit")]
11556 pub data_rate_unit: ::std::string::String,
11557 #[serde(rename = "DefaultTime")]
11558 pub default_time: ::std::string::String,
11559 #[serde(rename = "DeleteMode")]
11560 pub delete_mode: f64,
11561 #[serde(rename = "DisableFeatures")]
11562 pub disable_features: ::std::option::Option<::std::string::String>,
11563 #[serde(rename = "DisableHTTP2")]
11564 pub disable_http2: bool,
11565 #[serde(rename = "DisableHTTPKeepAlives")]
11566 pub disable_http_keep_alives: bool,
11567 #[serde(rename = "DownloadHeaders")]
11568 pub download_headers: ::std::option::Option<::std::string::String>,
11569 #[serde(rename = "DryRun")]
11570 pub dry_run: bool,
11571 #[serde(rename = "Dump")]
11572 pub dump: ::std::string::String,
11573 #[serde(rename = "ErrorOnNoTransfer")]
11574 pub error_on_no_transfer: bool,
11575 #[serde(rename = "ExpectContinueTimeout")]
11576 pub expect_continue_timeout: f64,
11577 #[serde(rename = "FixCase")]
11578 pub fix_case: bool,
11579 #[serde(rename = "FsCacheExpireDuration")]
11580 pub fs_cache_expire_duration: f64,
11581 #[serde(rename = "FsCacheExpireInterval")]
11582 pub fs_cache_expire_interval: f64,
11583 #[serde(rename = "Headers")]
11584 pub headers: ::std::option::Option<::std::string::String>,
11585 #[serde(rename = "HumanReadable")]
11586 pub human_readable: bool,
11587 #[serde(rename = "IgnoreCaseSync")]
11588 pub ignore_case_sync: bool,
11589 #[serde(rename = "IgnoreChecksum")]
11590 pub ignore_checksum: bool,
11591 #[serde(rename = "IgnoreErrors")]
11592 pub ignore_errors: bool,
11593 #[serde(rename = "IgnoreExisting")]
11594 pub ignore_existing: bool,
11595 #[serde(rename = "IgnoreSize")]
11596 pub ignore_size: bool,
11597 #[serde(rename = "IgnoreTimes")]
11598 pub ignore_times: bool,
11599 #[serde(rename = "Immutable")]
11600 pub immutable: bool,
11601 #[serde(rename = "Inplace")]
11602 pub inplace: bool,
11603 #[serde(rename = "InsecureSkipVerify")]
11604 pub insecure_skip_verify: bool,
11605 #[serde(rename = "Interactive")]
11606 pub interactive: bool,
11607 #[serde(rename = "KvLockTime")]
11608 pub kv_lock_time: f64,
11609 #[serde(rename = "Links")]
11610 pub links: bool,
11611 #[serde(rename = "LogLevel")]
11612 pub log_level: ::std::string::String,
11613 #[serde(rename = "LowLevelRetries")]
11614 pub low_level_retries: f64,
11615 #[serde(rename = "MaxBacklog")]
11616 pub max_backlog: f64,
11617 #[serde(rename = "MaxBufferMemory")]
11618 pub max_buffer_memory: f64,
11619 #[serde(rename = "MaxDelete")]
11620 pub max_delete: f64,
11621 #[serde(rename = "MaxDeleteSize")]
11622 pub max_delete_size: f64,
11623 #[serde(rename = "MaxDepth")]
11624 pub max_depth: f64,
11625 #[serde(rename = "MaxDuration")]
11626 pub max_duration: f64,
11627 #[serde(rename = "MaxStatsGroups")]
11628 pub max_stats_groups: f64,
11629 #[serde(rename = "MaxTransfer")]
11630 pub max_transfer: f64,
11631 #[serde(rename = "Metadata")]
11632 pub metadata: bool,
11633 #[serde(rename = "MetadataMapper")]
11634 pub metadata_mapper: ::std::option::Option<::std::string::String>,
11635 #[serde(rename = "MetadataSet")]
11636 pub metadata_set: ::std::option::Option<::std::string::String>,
11637 #[serde(rename = "ModifyWindow")]
11638 pub modify_window: f64,
11639 #[serde(rename = "MultiThreadChunkSize")]
11640 pub multi_thread_chunk_size: f64,
11641 #[serde(rename = "MultiThreadCutoff")]
11642 pub multi_thread_cutoff: f64,
11643 #[serde(rename = "MultiThreadSet")]
11644 pub multi_thread_set: bool,
11645 #[serde(rename = "MultiThreadStreams")]
11646 pub multi_thread_streams: f64,
11647 #[serde(rename = "MultiThreadWriteBufferSize")]
11648 pub multi_thread_write_buffer_size: f64,
11649 #[serde(rename = "NoCheckDest")]
11650 pub no_check_dest: bool,
11651 #[serde(rename = "NoConsole")]
11652 pub no_console: bool,
11653 #[serde(rename = "NoGzip")]
11654 pub no_gzip: bool,
11655 #[serde(rename = "NoTraverse")]
11656 pub no_traverse: bool,
11657 #[serde(rename = "NoUnicodeNormalization")]
11658 pub no_unicode_normalization: bool,
11659 #[serde(rename = "NoUpdateDirModTime")]
11660 pub no_update_dir_mod_time: bool,
11661 #[serde(rename = "NoUpdateModTime")]
11662 pub no_update_mod_time: bool,
11663 #[serde(rename = "OrderBy")]
11664 pub order_by: ::std::string::String,
11665 #[serde(rename = "PartialSuffix")]
11666 pub partial_suffix: ::std::string::String,
11667 #[serde(rename = "PasswordCommand")]
11668 pub password_command: ::std::option::Option<::std::string::String>,
11669 #[serde(rename = "Progress")]
11670 pub progress: bool,
11671 #[serde(rename = "ProgressTerminalTitle")]
11672 pub progress_terminal_title: bool,
11673 #[serde(rename = "RefreshTimes")]
11674 pub refresh_times: bool,
11675 #[serde(rename = "Retries")]
11676 pub retries: f64,
11677 #[serde(rename = "RetriesInterval")]
11678 pub retries_interval: f64,
11679 #[serde(rename = "ServerSideAcrossConfigs")]
11680 pub server_side_across_configs: bool,
11681 #[serde(rename = "SizeOnly")]
11682 pub size_only: bool,
11683 #[serde(rename = "StatsFileNameLength")]
11684 pub stats_file_name_length: f64,
11685 #[serde(rename = "StatsLogLevel")]
11686 pub stats_log_level: ::std::string::String,
11687 #[serde(rename = "StatsOneLine")]
11688 pub stats_one_line: bool,
11689 #[serde(rename = "StatsOneLineDate")]
11690 pub stats_one_line_date: bool,
11691 #[serde(rename = "StatsOneLineDateFormat")]
11692 pub stats_one_line_date_format: ::std::string::String,
11693 #[serde(rename = "StreamingUploadCutoff")]
11694 pub streaming_upload_cutoff: f64,
11695 #[serde(rename = "Suffix")]
11696 pub suffix: ::std::string::String,
11697 #[serde(rename = "SuffixKeepExtension")]
11698 pub suffix_keep_extension: bool,
11699 #[serde(rename = "TerminalColorMode")]
11700 pub terminal_color_mode: ::std::string::String,
11701 #[serde(rename = "Timeout")]
11702 pub timeout: f64,
11703 #[serde(rename = "TPSLimit")]
11704 pub tps_limit: f64,
11705 #[serde(rename = "TPSLimitBurst")]
11706 pub tps_limit_burst: f64,
11707 #[serde(rename = "TrackRenames")]
11708 pub track_renames: bool,
11709 #[serde(rename = "TrackRenamesStrategy")]
11710 pub track_renames_strategy: ::std::string::String,
11711 #[serde(rename = "TrafficClass")]
11712 pub traffic_class: f64,
11713 #[serde(rename = "Transfers")]
11714 pub transfers: f64,
11715 #[serde(rename = "UpdateOlder")]
11716 pub update_older: bool,
11717 #[serde(rename = "UploadHeaders")]
11718 pub upload_headers: ::std::option::Option<::std::string::String>,
11719 #[serde(rename = "UseJSONLog")]
11720 pub use_json_log: bool,
11721 #[serde(rename = "UseListR")]
11722 pub use_list_r: bool,
11723 #[serde(rename = "UseMmap")]
11724 pub use_mmap: bool,
11725 #[serde(rename = "UseServerModTime")]
11726 pub use_server_mod_time: bool,
11727 #[serde(rename = "UserAgent")]
11728 pub user_agent: ::std::string::String,
11729 }
11730
11731 impl ::std::convert::From<&OptionsLocalResponseConfig> for OptionsLocalResponseConfig {
11732 fn from(value: &OptionsLocalResponseConfig) -> Self {
11733 value.clone()
11734 }
11735 }
11736
11737 ///`OptionsLocalResponseFilter`
11738 ///
11739 /// <details><summary>JSON schema</summary>
11740 ///
11741 /// ```json
11742 ///{
11743 /// "type": "object",
11744 /// "required": [
11745 /// "DeleteExcluded",
11746 /// "ExcludeFile",
11747 /// "ExcludeFrom",
11748 /// "ExcludeRule",
11749 /// "FilesFrom",
11750 /// "FilesFromRaw",
11751 /// "FilterFrom",
11752 /// "FilterRule",
11753 /// "HashFilter",
11754 /// "IgnoreCase",
11755 /// "IncludeFrom",
11756 /// "IncludeRule",
11757 /// "MaxAge",
11758 /// "MaxSize",
11759 /// "MetaRules",
11760 /// "MinAge",
11761 /// "MinSize"
11762 /// ],
11763 /// "properties": {
11764 /// "DeleteExcluded": {
11765 /// "type": "boolean"
11766 /// },
11767 /// "ExcludeFile": {
11768 /// "type": "array",
11769 /// "items": {
11770 /// "type": "string"
11771 /// }
11772 /// },
11773 /// "ExcludeFrom": {
11774 /// "type": "array",
11775 /// "items": {
11776 /// "type": "string"
11777 /// }
11778 /// },
11779 /// "ExcludeRule": {
11780 /// "type": "array",
11781 /// "items": {
11782 /// "type": "string"
11783 /// }
11784 /// },
11785 /// "FilesFrom": {
11786 /// "type": "array",
11787 /// "items": {
11788 /// "type": "string"
11789 /// }
11790 /// },
11791 /// "FilesFromRaw": {
11792 /// "type": "array",
11793 /// "items": {
11794 /// "type": "string"
11795 /// }
11796 /// },
11797 /// "FilterFrom": {
11798 /// "type": "array",
11799 /// "items": {
11800 /// "type": "string"
11801 /// }
11802 /// },
11803 /// "FilterRule": {
11804 /// "type": "array",
11805 /// "items": {
11806 /// "type": "string"
11807 /// }
11808 /// },
11809 /// "HashFilter": {
11810 /// "type": "string"
11811 /// },
11812 /// "IgnoreCase": {
11813 /// "type": "boolean"
11814 /// },
11815 /// "IncludeFrom": {
11816 /// "type": "array",
11817 /// "items": {
11818 /// "type": "string"
11819 /// }
11820 /// },
11821 /// "IncludeRule": {
11822 /// "type": "array",
11823 /// "items": {
11824 /// "type": "string"
11825 /// }
11826 /// },
11827 /// "MaxAge": {
11828 /// "type": "number"
11829 /// },
11830 /// "MaxSize": {
11831 /// "type": "number"
11832 /// },
11833 /// "MetaRules": {
11834 /// "type": "object",
11835 /// "required": [
11836 /// "ExcludeFrom",
11837 /// "ExcludeRule",
11838 /// "FilterFrom",
11839 /// "FilterRule",
11840 /// "IncludeFrom",
11841 /// "IncludeRule"
11842 /// ],
11843 /// "properties": {
11844 /// "ExcludeFrom": {
11845 /// "type": "array",
11846 /// "items": {
11847 /// "type": "string"
11848 /// }
11849 /// },
11850 /// "ExcludeRule": {
11851 /// "type": "array",
11852 /// "items": {
11853 /// "type": "string"
11854 /// }
11855 /// },
11856 /// "FilterFrom": {
11857 /// "type": "array",
11858 /// "items": {
11859 /// "type": "string"
11860 /// }
11861 /// },
11862 /// "FilterRule": {
11863 /// "type": "array",
11864 /// "items": {
11865 /// "type": "string"
11866 /// }
11867 /// },
11868 /// "IncludeFrom": {
11869 /// "type": "array",
11870 /// "items": {
11871 /// "type": "string"
11872 /// }
11873 /// },
11874 /// "IncludeRule": {
11875 /// "type": "array",
11876 /// "items": {
11877 /// "type": "string"
11878 /// }
11879 /// }
11880 /// }
11881 /// },
11882 /// "MinAge": {
11883 /// "type": "number"
11884 /// },
11885 /// "MinSize": {
11886 /// "type": "number"
11887 /// }
11888 /// }
11889 ///}
11890 /// ```
11891 /// </details>
11892 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11893 pub struct OptionsLocalResponseFilter {
11894 #[serde(rename = "DeleteExcluded")]
11895 pub delete_excluded: bool,
11896 #[serde(rename = "ExcludeFile")]
11897 pub exclude_file: ::std::vec::Vec<::std::string::String>,
11898 #[serde(rename = "ExcludeFrom")]
11899 pub exclude_from: ::std::vec::Vec<::std::string::String>,
11900 #[serde(rename = "ExcludeRule")]
11901 pub exclude_rule: ::std::vec::Vec<::std::string::String>,
11902 #[serde(rename = "FilesFrom")]
11903 pub files_from: ::std::vec::Vec<::std::string::String>,
11904 #[serde(rename = "FilesFromRaw")]
11905 pub files_from_raw: ::std::vec::Vec<::std::string::String>,
11906 #[serde(rename = "FilterFrom")]
11907 pub filter_from: ::std::vec::Vec<::std::string::String>,
11908 #[serde(rename = "FilterRule")]
11909 pub filter_rule: ::std::vec::Vec<::std::string::String>,
11910 #[serde(rename = "HashFilter")]
11911 pub hash_filter: ::std::string::String,
11912 #[serde(rename = "IgnoreCase")]
11913 pub ignore_case: bool,
11914 #[serde(rename = "IncludeFrom")]
11915 pub include_from: ::std::vec::Vec<::std::string::String>,
11916 #[serde(rename = "IncludeRule")]
11917 pub include_rule: ::std::vec::Vec<::std::string::String>,
11918 #[serde(rename = "MaxAge")]
11919 pub max_age: f64,
11920 #[serde(rename = "MaxSize")]
11921 pub max_size: f64,
11922 #[serde(rename = "MetaRules")]
11923 pub meta_rules: OptionsLocalResponseFilterMetaRules,
11924 #[serde(rename = "MinAge")]
11925 pub min_age: f64,
11926 #[serde(rename = "MinSize")]
11927 pub min_size: f64,
11928 }
11929
11930 impl ::std::convert::From<&OptionsLocalResponseFilter> for OptionsLocalResponseFilter {
11931 fn from(value: &OptionsLocalResponseFilter) -> Self {
11932 value.clone()
11933 }
11934 }
11935
11936 ///`OptionsLocalResponseFilterMetaRules`
11937 ///
11938 /// <details><summary>JSON schema</summary>
11939 ///
11940 /// ```json
11941 ///{
11942 /// "type": "object",
11943 /// "required": [
11944 /// "ExcludeFrom",
11945 /// "ExcludeRule",
11946 /// "FilterFrom",
11947 /// "FilterRule",
11948 /// "IncludeFrom",
11949 /// "IncludeRule"
11950 /// ],
11951 /// "properties": {
11952 /// "ExcludeFrom": {
11953 /// "type": "array",
11954 /// "items": {
11955 /// "type": "string"
11956 /// }
11957 /// },
11958 /// "ExcludeRule": {
11959 /// "type": "array",
11960 /// "items": {
11961 /// "type": "string"
11962 /// }
11963 /// },
11964 /// "FilterFrom": {
11965 /// "type": "array",
11966 /// "items": {
11967 /// "type": "string"
11968 /// }
11969 /// },
11970 /// "FilterRule": {
11971 /// "type": "array",
11972 /// "items": {
11973 /// "type": "string"
11974 /// }
11975 /// },
11976 /// "IncludeFrom": {
11977 /// "type": "array",
11978 /// "items": {
11979 /// "type": "string"
11980 /// }
11981 /// },
11982 /// "IncludeRule": {
11983 /// "type": "array",
11984 /// "items": {
11985 /// "type": "string"
11986 /// }
11987 /// }
11988 /// }
11989 ///}
11990 /// ```
11991 /// </details>
11992 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11993 pub struct OptionsLocalResponseFilterMetaRules {
11994 #[serde(rename = "ExcludeFrom")]
11995 pub exclude_from: ::std::vec::Vec<::std::string::String>,
11996 #[serde(rename = "ExcludeRule")]
11997 pub exclude_rule: ::std::vec::Vec<::std::string::String>,
11998 #[serde(rename = "FilterFrom")]
11999 pub filter_from: ::std::vec::Vec<::std::string::String>,
12000 #[serde(rename = "FilterRule")]
12001 pub filter_rule: ::std::vec::Vec<::std::string::String>,
12002 #[serde(rename = "IncludeFrom")]
12003 pub include_from: ::std::vec::Vec<::std::string::String>,
12004 #[serde(rename = "IncludeRule")]
12005 pub include_rule: ::std::vec::Vec<::std::string::String>,
12006 }
12007
12008 impl ::std::convert::From<&OptionsLocalResponseFilterMetaRules>
12009 for OptionsLocalResponseFilterMetaRules
12010 {
12011 fn from(value: &OptionsLocalResponseFilterMetaRules) -> Self {
12012 value.clone()
12013 }
12014 }
12015
12016 ///`OptionsSetRequest`
12017 ///
12018 /// <details><summary>JSON schema</summary>
12019 ///
12020 /// ```json
12021 ///{
12022 /// "type": "object",
12023 /// "properties": {
12024 /// "_async": {
12025 /// "description": "Run the command asynchronously. Returns a job id
12026 /// immediately.",
12027 /// "type": "boolean"
12028 /// },
12029 /// "_group": {
12030 /// "description": "Assign the request to a custom stats group.",
12031 /// "type": "string"
12032 /// },
12033 /// "dlna": {
12034 /// "description": "Overrides for the `dlna` option block.",
12035 /// "type": "object",
12036 /// "additionalProperties": true
12037 /// },
12038 /// "filter": {
12039 /// "description": "Overrides for the `filter` option block.",
12040 /// "type": "object",
12041 /// "additionalProperties": true
12042 /// },
12043 /// "ftp": {
12044 /// "description": "Overrides for the `ftp` option block.",
12045 /// "type": "object",
12046 /// "additionalProperties": true
12047 /// },
12048 /// "http": {
12049 /// "description": "Overrides for the `http` option block.",
12050 /// "type": "object",
12051 /// "additionalProperties": true
12052 /// },
12053 /// "log": {
12054 /// "description": "Overrides for the `log` option block.",
12055 /// "type": "object",
12056 /// "additionalProperties": true
12057 /// },
12058 /// "main": {
12059 /// "description": "Overrides for the `main` option block.",
12060 /// "type": "object",
12061 /// "additionalProperties": true
12062 /// },
12063 /// "mount": {
12064 /// "description": "Overrides for the `mount` option block.",
12065 /// "type": "object",
12066 /// "additionalProperties": true
12067 /// },
12068 /// "nfs": {
12069 /// "description": "Overrides for the `nfs` option block.",
12070 /// "type": "object",
12071 /// "additionalProperties": true
12072 /// },
12073 /// "proxy": {
12074 /// "description": "Overrides for the `proxy` option block.",
12075 /// "type": "object",
12076 /// "additionalProperties": true
12077 /// },
12078 /// "rc": {
12079 /// "description": "Overrides for the `rc` option block.",
12080 /// "type": "object",
12081 /// "additionalProperties": true
12082 /// },
12083 /// "restic": {
12084 /// "description": "Overrides for the `restic` option block.",
12085 /// "type": "object",
12086 /// "additionalProperties": true
12087 /// },
12088 /// "s3": {
12089 /// "description": "Overrides for the `s3` option block.",
12090 /// "type": "object",
12091 /// "additionalProperties": true
12092 /// },
12093 /// "sftp": {
12094 /// "description": "Overrides for the `sftp` option block.",
12095 /// "type": "object",
12096 /// "additionalProperties": true
12097 /// },
12098 /// "vfs": {
12099 /// "description": "Overrides for the `vfs` option block.",
12100 /// "type": "object",
12101 /// "additionalProperties": true
12102 /// },
12103 /// "webdav": {
12104 /// "description": "Overrides for the `webdav` option block.",
12105 /// "type": "object",
12106 /// "additionalProperties": true
12107 /// }
12108 /// },
12109 /// "additionalProperties": true
12110 ///}
12111 /// ```
12112 /// </details>
12113 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12114 pub struct OptionsSetRequest {
12115 ///Run the command asynchronously. Returns a job id immediately.
12116 #[serde(
12117 rename = "_async",
12118 default,
12119 skip_serializing_if = "::std::option::Option::is_none"
12120 )]
12121 pub async_: ::std::option::Option<bool>,
12122 ///Overrides for the `dlna` option block.
12123 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12124 pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12125 ///Overrides for the `filter` option block.
12126 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12127 pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12128 ///Overrides for the `ftp` option block.
12129 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12130 pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12131 ///Assign the request to a custom stats group.
12132 #[serde(
12133 rename = "_group",
12134 default,
12135 skip_serializing_if = "::std::option::Option::is_none"
12136 )]
12137 pub group: ::std::option::Option<::std::string::String>,
12138 ///Overrides for the `http` option block.
12139 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12140 pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12141 ///Overrides for the `log` option block.
12142 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12143 pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12144 ///Overrides for the `main` option block.
12145 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12146 pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12147 ///Overrides for the `mount` option block.
12148 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12149 pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12150 ///Overrides for the `nfs` option block.
12151 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12152 pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12153 ///Overrides for the `proxy` option block.
12154 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12155 pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12156 ///Overrides for the `rc` option block.
12157 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12158 pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12159 ///Overrides for the `restic` option block.
12160 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12161 pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12162 ///Overrides for the `s3` option block.
12163 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12164 pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12165 ///Overrides for the `sftp` option block.
12166 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12167 pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12168 ///Overrides for the `vfs` option block.
12169 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12170 pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12171 ///Overrides for the `webdav` option block.
12172 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
12173 pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12174 }
12175
12176 impl ::std::convert::From<&OptionsSetRequest> for OptionsSetRequest {
12177 fn from(value: &OptionsSetRequest) -> Self {
12178 value.clone()
12179 }
12180 }
12181
12182 impl ::std::default::Default for OptionsSetRequest {
12183 fn default() -> Self {
12184 Self {
12185 async_: Default::default(),
12186 dlna: Default::default(),
12187 filter: Default::default(),
12188 ftp: Default::default(),
12189 group: Default::default(),
12190 http: Default::default(),
12191 log: Default::default(),
12192 main: Default::default(),
12193 mount: Default::default(),
12194 nfs: Default::default(),
12195 proxy: Default::default(),
12196 rc: Default::default(),
12197 restic: Default::default(),
12198 s3: Default::default(),
12199 sftp: Default::default(),
12200 vfs: Default::default(),
12201 webdav: Default::default(),
12202 }
12203 }
12204 }
12205
12206 ///`OptionsSetResponse`
12207 ///
12208 /// <details><summary>JSON schema</summary>
12209 ///
12210 /// ```json
12211 ///{
12212 /// "type": "object",
12213 /// "properties": {
12214 /// "jobid": {
12215 /// "description": "Job ID returned when _async=true.",
12216 /// "type": "integer"
12217 /// }
12218 /// },
12219 /// "additionalProperties": true
12220 ///}
12221 /// ```
12222 /// </details>
12223 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12224 pub struct OptionsSetResponse {
12225 ///Job ID returned when _async=true.
12226 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12227 pub jobid: ::std::option::Option<i64>,
12228 }
12229
12230 impl ::std::convert::From<&OptionsSetResponse> for OptionsSetResponse {
12231 fn from(value: &OptionsSetResponse) -> Self {
12232 value.clone()
12233 }
12234 }
12235
12236 impl ::std::default::Default for OptionsSetResponse {
12237 fn default() -> Self {
12238 Self {
12239 jobid: Default::default(),
12240 }
12241 }
12242 }
12243
12244 ///`PluginsctlAddPluginRequest`
12245 ///
12246 /// <details><summary>JSON schema</summary>
12247 ///
12248 /// ```json
12249 ///{
12250 /// "type": "object",
12251 /// "properties": {
12252 /// "_async": {
12253 /// "description": "Run the command asynchronously. Returns a job id
12254 /// immediately.",
12255 /// "type": "boolean"
12256 /// },
12257 /// "_group": {
12258 /// "description": "Assign the request to a custom stats group.",
12259 /// "type": "string"
12260 /// },
12261 /// "url": {
12262 /// "description": "Repository URL of the plugin to install.",
12263 /// "type": "string"
12264 /// }
12265 /// }
12266 ///}
12267 /// ```
12268 /// </details>
12269 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12270 pub struct PluginsctlAddPluginRequest {
12271 ///Run the command asynchronously. Returns a job id immediately.
12272 #[serde(
12273 rename = "_async",
12274 default,
12275 skip_serializing_if = "::std::option::Option::is_none"
12276 )]
12277 pub async_: ::std::option::Option<bool>,
12278 ///Assign the request to a custom stats group.
12279 #[serde(
12280 rename = "_group",
12281 default,
12282 skip_serializing_if = "::std::option::Option::is_none"
12283 )]
12284 pub group: ::std::option::Option<::std::string::String>,
12285 ///Repository URL of the plugin to install.
12286 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12287 pub url: ::std::option::Option<::std::string::String>,
12288 }
12289
12290 impl ::std::convert::From<&PluginsctlAddPluginRequest> for PluginsctlAddPluginRequest {
12291 fn from(value: &PluginsctlAddPluginRequest) -> Self {
12292 value.clone()
12293 }
12294 }
12295
12296 impl ::std::default::Default for PluginsctlAddPluginRequest {
12297 fn default() -> Self {
12298 Self {
12299 async_: Default::default(),
12300 group: Default::default(),
12301 url: Default::default(),
12302 }
12303 }
12304 }
12305
12306 ///`PluginsctlAddPluginResponse`
12307 ///
12308 /// <details><summary>JSON schema</summary>
12309 ///
12310 /// ```json
12311 ///{
12312 /// "type": "object",
12313 /// "properties": {
12314 /// "jobid": {
12315 /// "description": "Job ID returned when _async=true.",
12316 /// "type": "integer"
12317 /// }
12318 /// },
12319 /// "additionalProperties": true
12320 ///}
12321 /// ```
12322 /// </details>
12323 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12324 pub struct PluginsctlAddPluginResponse {
12325 ///Job ID returned when _async=true.
12326 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12327 pub jobid: ::std::option::Option<i64>,
12328 }
12329
12330 impl ::std::convert::From<&PluginsctlAddPluginResponse> for PluginsctlAddPluginResponse {
12331 fn from(value: &PluginsctlAddPluginResponse) -> Self {
12332 value.clone()
12333 }
12334 }
12335
12336 impl ::std::default::Default for PluginsctlAddPluginResponse {
12337 fn default() -> Self {
12338 Self {
12339 jobid: Default::default(),
12340 }
12341 }
12342 }
12343
12344 ///`PluginsctlGetPluginsForTypeRequest`
12345 ///
12346 /// <details><summary>JSON schema</summary>
12347 ///
12348 /// ```json
12349 ///{
12350 /// "type": "object",
12351 /// "properties": {
12352 /// "_async": {
12353 /// "description": "Run the command asynchronously. Returns a job id
12354 /// immediately.",
12355 /// "type": "boolean"
12356 /// },
12357 /// "_group": {
12358 /// "description": "Assign the request to a custom stats group.",
12359 /// "type": "string"
12360 /// },
12361 /// "pluginType": {
12362 /// "description": "Filter results by plugin type (e.g. `test`).",
12363 /// "type": "string"
12364 /// },
12365 /// "type": {
12366 /// "description": "MIME type to match when listing plugins.",
12367 /// "type": "string"
12368 /// }
12369 /// }
12370 ///}
12371 /// ```
12372 /// </details>
12373 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12374 pub struct PluginsctlGetPluginsForTypeRequest {
12375 ///Run the command asynchronously. Returns a job id immediately.
12376 #[serde(
12377 rename = "_async",
12378 default,
12379 skip_serializing_if = "::std::option::Option::is_none"
12380 )]
12381 pub async_: ::std::option::Option<bool>,
12382 ///Assign the request to a custom stats group.
12383 #[serde(
12384 rename = "_group",
12385 default,
12386 skip_serializing_if = "::std::option::Option::is_none"
12387 )]
12388 pub group: ::std::option::Option<::std::string::String>,
12389 ///Filter results by plugin type (e.g. `test`).
12390 #[serde(
12391 rename = "pluginType",
12392 default,
12393 skip_serializing_if = "::std::option::Option::is_none"
12394 )]
12395 pub plugin_type: ::std::option::Option<::std::string::String>,
12396 ///MIME type to match when listing plugins.
12397 #[serde(
12398 rename = "type",
12399 default,
12400 skip_serializing_if = "::std::option::Option::is_none"
12401 )]
12402 pub type_: ::std::option::Option<::std::string::String>,
12403 }
12404
12405 impl ::std::convert::From<&PluginsctlGetPluginsForTypeRequest>
12406 for PluginsctlGetPluginsForTypeRequest
12407 {
12408 fn from(value: &PluginsctlGetPluginsForTypeRequest) -> Self {
12409 value.clone()
12410 }
12411 }
12412
12413 impl ::std::default::Default for PluginsctlGetPluginsForTypeRequest {
12414 fn default() -> Self {
12415 Self {
12416 async_: Default::default(),
12417 group: Default::default(),
12418 plugin_type: Default::default(),
12419 type_: Default::default(),
12420 }
12421 }
12422 }
12423
12424 ///`PluginsctlGetPluginsForTypeResponse`
12425 ///
12426 /// <details><summary>JSON schema</summary>
12427 ///
12428 /// ```json
12429 ///{
12430 /// "type": "object",
12431 /// "required": [
12432 /// "loadedPlugins",
12433 /// "loadedTestPlugins"
12434 /// ],
12435 /// "properties": {
12436 /// "loadedPlugins": {
12437 /// "description": "Installed plugins keyed by repository name.",
12438 /// "type": "object",
12439 /// "additionalProperties": {
12440 /// "type": "object",
12441 /// "additionalProperties": true
12442 /// }
12443 /// },
12444 /// "loadedTestPlugins": {
12445 /// "description": "Installed test plugins keyed by repository name.",
12446 /// "type": "object",
12447 /// "additionalProperties": {
12448 /// "type": "object",
12449 /// "additionalProperties": true
12450 /// }
12451 /// }
12452 /// }
12453 ///}
12454 /// ```
12455 /// </details>
12456 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12457 pub struct PluginsctlGetPluginsForTypeResponse {
12458 ///Installed plugins keyed by repository name.
12459 #[serde(rename = "loadedPlugins")]
12460 pub loaded_plugins: ::std::collections::HashMap<
12461 ::std::string::String,
12462 ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12463 >,
12464 ///Installed test plugins keyed by repository name.
12465 #[serde(rename = "loadedTestPlugins")]
12466 pub loaded_test_plugins: ::std::collections::HashMap<
12467 ::std::string::String,
12468 ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12469 >,
12470 }
12471
12472 impl ::std::convert::From<&PluginsctlGetPluginsForTypeResponse>
12473 for PluginsctlGetPluginsForTypeResponse
12474 {
12475 fn from(value: &PluginsctlGetPluginsForTypeResponse) -> Self {
12476 value.clone()
12477 }
12478 }
12479
12480 ///`PluginsctlListPluginsRequest`
12481 ///
12482 /// <details><summary>JSON schema</summary>
12483 ///
12484 /// ```json
12485 ///{
12486 /// "type": "object",
12487 /// "properties": {
12488 /// "_async": {
12489 /// "description": "Run the command asynchronously. Returns a job id
12490 /// immediately.",
12491 /// "type": "boolean"
12492 /// },
12493 /// "_group": {
12494 /// "description": "Assign the request to a custom stats group.",
12495 /// "type": "string"
12496 /// }
12497 /// }
12498 ///}
12499 /// ```
12500 /// </details>
12501 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12502 pub struct PluginsctlListPluginsRequest {
12503 ///Run the command asynchronously. Returns a job id immediately.
12504 #[serde(
12505 rename = "_async",
12506 default,
12507 skip_serializing_if = "::std::option::Option::is_none"
12508 )]
12509 pub async_: ::std::option::Option<bool>,
12510 ///Assign the request to a custom stats group.
12511 #[serde(
12512 rename = "_group",
12513 default,
12514 skip_serializing_if = "::std::option::Option::is_none"
12515 )]
12516 pub group: ::std::option::Option<::std::string::String>,
12517 }
12518
12519 impl ::std::convert::From<&PluginsctlListPluginsRequest> for PluginsctlListPluginsRequest {
12520 fn from(value: &PluginsctlListPluginsRequest) -> Self {
12521 value.clone()
12522 }
12523 }
12524
12525 impl ::std::default::Default for PluginsctlListPluginsRequest {
12526 fn default() -> Self {
12527 Self {
12528 async_: Default::default(),
12529 group: Default::default(),
12530 }
12531 }
12532 }
12533
12534 ///`PluginsctlListPluginsResponse`
12535 ///
12536 /// <details><summary>JSON schema</summary>
12537 ///
12538 /// ```json
12539 ///{
12540 /// "type": "object",
12541 /// "required": [
12542 /// "loadedPlugins",
12543 /// "testPlugins"
12544 /// ],
12545 /// "properties": {
12546 /// "loadedPlugins": {
12547 /// "description": "Metadata entries for installed plugins.",
12548 /// "type": "array",
12549 /// "items": {
12550 /// "type": "object",
12551 /// "additionalProperties": true
12552 /// }
12553 /// },
12554 /// "testPlugins": {
12555 /// "description": "Metadata entries for installed test plugins.",
12556 /// "type": "array",
12557 /// "items": {
12558 /// "type": "object",
12559 /// "additionalProperties": true
12560 /// }
12561 /// }
12562 /// }
12563 ///}
12564 /// ```
12565 /// </details>
12566 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12567 pub struct PluginsctlListPluginsResponse {
12568 ///Metadata entries for installed plugins.
12569 #[serde(rename = "loadedPlugins")]
12570 pub loaded_plugins:
12571 ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12572 ///Metadata entries for installed test plugins.
12573 #[serde(rename = "testPlugins")]
12574 pub test_plugins:
12575 ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12576 }
12577
12578 impl ::std::convert::From<&PluginsctlListPluginsResponse> for PluginsctlListPluginsResponse {
12579 fn from(value: &PluginsctlListPluginsResponse) -> Self {
12580 value.clone()
12581 }
12582 }
12583
12584 ///`PluginsctlListTestPluginsRequest`
12585 ///
12586 /// <details><summary>JSON schema</summary>
12587 ///
12588 /// ```json
12589 ///{
12590 /// "type": "object",
12591 /// "properties": {
12592 /// "_async": {
12593 /// "description": "Run the command asynchronously. Returns a job id
12594 /// immediately.",
12595 /// "type": "boolean"
12596 /// },
12597 /// "_group": {
12598 /// "description": "Assign the request to a custom stats group.",
12599 /// "type": "string"
12600 /// }
12601 /// }
12602 ///}
12603 /// ```
12604 /// </details>
12605 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12606 pub struct PluginsctlListTestPluginsRequest {
12607 ///Run the command asynchronously. Returns a job id immediately.
12608 #[serde(
12609 rename = "_async",
12610 default,
12611 skip_serializing_if = "::std::option::Option::is_none"
12612 )]
12613 pub async_: ::std::option::Option<bool>,
12614 ///Assign the request to a custom stats group.
12615 #[serde(
12616 rename = "_group",
12617 default,
12618 skip_serializing_if = "::std::option::Option::is_none"
12619 )]
12620 pub group: ::std::option::Option<::std::string::String>,
12621 }
12622
12623 impl ::std::convert::From<&PluginsctlListTestPluginsRequest> for PluginsctlListTestPluginsRequest {
12624 fn from(value: &PluginsctlListTestPluginsRequest) -> Self {
12625 value.clone()
12626 }
12627 }
12628
12629 impl ::std::default::Default for PluginsctlListTestPluginsRequest {
12630 fn default() -> Self {
12631 Self {
12632 async_: Default::default(),
12633 group: Default::default(),
12634 }
12635 }
12636 }
12637
12638 ///`PluginsctlListTestPluginsResponse`
12639 ///
12640 /// <details><summary>JSON schema</summary>
12641 ///
12642 /// ```json
12643 ///{
12644 /// "type": "object",
12645 /// "required": [
12646 /// "loadedTestPlugins"
12647 /// ],
12648 /// "properties": {
12649 /// "loadedTestPlugins": {
12650 /// "description": "Installed test plugin metadata keyed by
12651 /// repository.",
12652 /// "type": "object",
12653 /// "additionalProperties": {
12654 /// "type": "object",
12655 /// "additionalProperties": true
12656 /// }
12657 /// }
12658 /// }
12659 ///}
12660 /// ```
12661 /// </details>
12662 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12663 pub struct PluginsctlListTestPluginsResponse {
12664 ///Installed test plugin metadata keyed by repository.
12665 #[serde(rename = "loadedTestPlugins")]
12666 pub loaded_test_plugins: ::std::collections::HashMap<
12667 ::std::string::String,
12668 ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12669 >,
12670 }
12671
12672 impl ::std::convert::From<&PluginsctlListTestPluginsResponse>
12673 for PluginsctlListTestPluginsResponse
12674 {
12675 fn from(value: &PluginsctlListTestPluginsResponse) -> Self {
12676 value.clone()
12677 }
12678 }
12679
12680 ///`PluginsctlRemovePluginRequest`
12681 ///
12682 /// <details><summary>JSON schema</summary>
12683 ///
12684 /// ```json
12685 ///{
12686 /// "type": "object",
12687 /// "properties": {
12688 /// "_async": {
12689 /// "description": "Run the command asynchronously. Returns a job id
12690 /// immediately.",
12691 /// "type": "boolean"
12692 /// },
12693 /// "_group": {
12694 /// "description": "Assign the request to a custom stats group.",
12695 /// "type": "string"
12696 /// },
12697 /// "name": {
12698 /// "description": "Name of the plugin to uninstall.",
12699 /// "type": "string"
12700 /// }
12701 /// }
12702 ///}
12703 /// ```
12704 /// </details>
12705 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12706 pub struct PluginsctlRemovePluginRequest {
12707 ///Run the command asynchronously. Returns a job id immediately.
12708 #[serde(
12709 rename = "_async",
12710 default,
12711 skip_serializing_if = "::std::option::Option::is_none"
12712 )]
12713 pub async_: ::std::option::Option<bool>,
12714 ///Assign the request to a custom stats group.
12715 #[serde(
12716 rename = "_group",
12717 default,
12718 skip_serializing_if = "::std::option::Option::is_none"
12719 )]
12720 pub group: ::std::option::Option<::std::string::String>,
12721 ///Name of the plugin to uninstall.
12722 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12723 pub name: ::std::option::Option<::std::string::String>,
12724 }
12725
12726 impl ::std::convert::From<&PluginsctlRemovePluginRequest> for PluginsctlRemovePluginRequest {
12727 fn from(value: &PluginsctlRemovePluginRequest) -> Self {
12728 value.clone()
12729 }
12730 }
12731
12732 impl ::std::default::Default for PluginsctlRemovePluginRequest {
12733 fn default() -> Self {
12734 Self {
12735 async_: Default::default(),
12736 group: Default::default(),
12737 name: Default::default(),
12738 }
12739 }
12740 }
12741
12742 ///`PluginsctlRemoveTestPluginRequest`
12743 ///
12744 /// <details><summary>JSON schema</summary>
12745 ///
12746 /// ```json
12747 ///{
12748 /// "type": "object",
12749 /// "properties": {
12750 /// "_async": {
12751 /// "description": "Run the command asynchronously. Returns a job id
12752 /// immediately.",
12753 /// "type": "boolean"
12754 /// },
12755 /// "_group": {
12756 /// "description": "Assign the request to a custom stats group.",
12757 /// "type": "string"
12758 /// },
12759 /// "name": {
12760 /// "description": "Name of the test plugin to uninstall.",
12761 /// "type": "string"
12762 /// }
12763 /// }
12764 ///}
12765 /// ```
12766 /// </details>
12767 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12768 pub struct PluginsctlRemoveTestPluginRequest {
12769 ///Run the command asynchronously. Returns a job id immediately.
12770 #[serde(
12771 rename = "_async",
12772 default,
12773 skip_serializing_if = "::std::option::Option::is_none"
12774 )]
12775 pub async_: ::std::option::Option<bool>,
12776 ///Assign the request to a custom stats group.
12777 #[serde(
12778 rename = "_group",
12779 default,
12780 skip_serializing_if = "::std::option::Option::is_none"
12781 )]
12782 pub group: ::std::option::Option<::std::string::String>,
12783 ///Name of the test plugin to uninstall.
12784 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12785 pub name: ::std::option::Option<::std::string::String>,
12786 }
12787
12788 impl ::std::convert::From<&PluginsctlRemoveTestPluginRequest>
12789 for PluginsctlRemoveTestPluginRequest
12790 {
12791 fn from(value: &PluginsctlRemoveTestPluginRequest) -> Self {
12792 value.clone()
12793 }
12794 }
12795
12796 impl ::std::default::Default for PluginsctlRemoveTestPluginRequest {
12797 fn default() -> Self {
12798 Self {
12799 async_: Default::default(),
12800 group: Default::default(),
12801 name: Default::default(),
12802 }
12803 }
12804 }
12805
12806 ///`RcError`
12807 ///
12808 /// <details><summary>JSON schema</summary>
12809 ///
12810 /// ```json
12811 ///{
12812 /// "type": "object",
12813 /// "required": [
12814 /// "error",
12815 /// "input",
12816 /// "path",
12817 /// "status"
12818 /// ],
12819 /// "properties": {
12820 /// "error": {
12821 /// "type": "string"
12822 /// },
12823 /// "input": {
12824 /// "description": "Original request parameters echoed for debugging.",
12825 /// "type": [
12826 /// "object",
12827 /// "null"
12828 /// ],
12829 /// "additionalProperties": {}
12830 /// },
12831 /// "path": {
12832 /// "type": "string"
12833 /// },
12834 /// "status": {
12835 /// "type": "integer"
12836 /// }
12837 /// }
12838 ///}
12839 /// ```
12840 /// </details>
12841 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12842 pub struct RcError {
12843 pub error: ::std::string::String,
12844 ///Original request parameters echoed for debugging.
12845 pub input:
12846 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12847 pub path: ::std::string::String,
12848 pub status: i64,
12849 }
12850
12851 impl ::std::convert::From<&RcError> for RcError {
12852 fn from(value: &RcError) -> Self {
12853 value.clone()
12854 }
12855 }
12856
12857 ///`RcErrorRequest`
12858 ///
12859 /// <details><summary>JSON schema</summary>
12860 ///
12861 /// ```json
12862 ///{
12863 /// "type": "object",
12864 /// "properties": {
12865 /// "_async": {
12866 /// "description": "Run the command asynchronously. Returns a job id
12867 /// immediately.",
12868 /// "type": "boolean"
12869 /// }
12870 /// },
12871 /// "additionalProperties": true
12872 ///}
12873 /// ```
12874 /// </details>
12875 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12876 pub struct RcErrorRequest {
12877 ///Run the command asynchronously. Returns a job id immediately.
12878 #[serde(
12879 rename = "_async",
12880 default,
12881 skip_serializing_if = "::std::option::Option::is_none"
12882 )]
12883 pub async_: ::std::option::Option<bool>,
12884 }
12885
12886 impl ::std::convert::From<&RcErrorRequest> for RcErrorRequest {
12887 fn from(value: &RcErrorRequest) -> Self {
12888 value.clone()
12889 }
12890 }
12891
12892 impl ::std::default::Default for RcErrorRequest {
12893 fn default() -> Self {
12894 Self {
12895 async_: Default::default(),
12896 }
12897 }
12898 }
12899
12900 ///`RcListRequest`
12901 ///
12902 /// <details><summary>JSON schema</summary>
12903 ///
12904 /// ```json
12905 ///{
12906 /// "type": "object",
12907 /// "properties": {
12908 /// "_async": {
12909 /// "description": "Run the command asynchronously. Returns a job id
12910 /// immediately.",
12911 /// "type": "boolean"
12912 /// },
12913 /// "_group": {
12914 /// "description": "Assign the request to a custom stats group.",
12915 /// "type": "string"
12916 /// }
12917 /// }
12918 ///}
12919 /// ```
12920 /// </details>
12921 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12922 pub struct RcListRequest {
12923 ///Run the command asynchronously. Returns a job id immediately.
12924 #[serde(
12925 rename = "_async",
12926 default,
12927 skip_serializing_if = "::std::option::Option::is_none"
12928 )]
12929 pub async_: ::std::option::Option<bool>,
12930 ///Assign the request to a custom stats group.
12931 #[serde(
12932 rename = "_group",
12933 default,
12934 skip_serializing_if = "::std::option::Option::is_none"
12935 )]
12936 pub group: ::std::option::Option<::std::string::String>,
12937 }
12938
12939 impl ::std::convert::From<&RcListRequest> for RcListRequest {
12940 fn from(value: &RcListRequest) -> Self {
12941 value.clone()
12942 }
12943 }
12944
12945 impl ::std::default::Default for RcListRequest {
12946 fn default() -> Self {
12947 Self {
12948 async_: Default::default(),
12949 group: Default::default(),
12950 }
12951 }
12952 }
12953
12954 ///`RcListResponse`
12955 ///
12956 /// <details><summary>JSON schema</summary>
12957 ///
12958 /// ```json
12959 ///{
12960 /// "type": "object",
12961 /// "required": [
12962 /// "commands"
12963 /// ],
12964 /// "properties": {
12965 /// "commands": {
12966 /// "type": "array",
12967 /// "items": {
12968 /// "type": "object",
12969 /// "properties": {
12970 /// "AuthRequired": {
12971 /// "type": "boolean"
12972 /// },
12973 /// "Help": {
12974 /// "type": "string"
12975 /// },
12976 /// "NeedsRequest": {
12977 /// "type": "boolean"
12978 /// },
12979 /// "NeedsResponse": {
12980 /// "type": "boolean"
12981 /// },
12982 /// "Path": {
12983 /// "type": "string"
12984 /// },
12985 /// "Title": {
12986 /// "type": "string"
12987 /// }
12988 /// },
12989 /// "additionalProperties": true
12990 /// }
12991 /// }
12992 /// }
12993 ///}
12994 /// ```
12995 /// </details>
12996 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12997 pub struct RcListResponse {
12998 pub commands: ::std::vec::Vec<RcListResponseCommandsItem>,
12999 }
13000
13001 impl ::std::convert::From<&RcListResponse> for RcListResponse {
13002 fn from(value: &RcListResponse) -> Self {
13003 value.clone()
13004 }
13005 }
13006
13007 ///`RcListResponseCommandsItem`
13008 ///
13009 /// <details><summary>JSON schema</summary>
13010 ///
13011 /// ```json
13012 ///{
13013 /// "type": "object",
13014 /// "properties": {
13015 /// "AuthRequired": {
13016 /// "type": "boolean"
13017 /// },
13018 /// "Help": {
13019 /// "type": "string"
13020 /// },
13021 /// "NeedsRequest": {
13022 /// "type": "boolean"
13023 /// },
13024 /// "NeedsResponse": {
13025 /// "type": "boolean"
13026 /// },
13027 /// "Path": {
13028 /// "type": "string"
13029 /// },
13030 /// "Title": {
13031 /// "type": "string"
13032 /// }
13033 /// },
13034 /// "additionalProperties": true
13035 ///}
13036 /// ```
13037 /// </details>
13038 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13039 pub struct RcListResponseCommandsItem {
13040 #[serde(
13041 rename = "AuthRequired",
13042 default,
13043 skip_serializing_if = "::std::option::Option::is_none"
13044 )]
13045 pub auth_required: ::std::option::Option<bool>,
13046 #[serde(
13047 rename = "Help",
13048 default,
13049 skip_serializing_if = "::std::option::Option::is_none"
13050 )]
13051 pub help: ::std::option::Option<::std::string::String>,
13052 #[serde(
13053 rename = "NeedsRequest",
13054 default,
13055 skip_serializing_if = "::std::option::Option::is_none"
13056 )]
13057 pub needs_request: ::std::option::Option<bool>,
13058 #[serde(
13059 rename = "NeedsResponse",
13060 default,
13061 skip_serializing_if = "::std::option::Option::is_none"
13062 )]
13063 pub needs_response: ::std::option::Option<bool>,
13064 #[serde(
13065 rename = "Path",
13066 default,
13067 skip_serializing_if = "::std::option::Option::is_none"
13068 )]
13069 pub path: ::std::option::Option<::std::string::String>,
13070 #[serde(
13071 rename = "Title",
13072 default,
13073 skip_serializing_if = "::std::option::Option::is_none"
13074 )]
13075 pub title: ::std::option::Option<::std::string::String>,
13076 }
13077
13078 impl ::std::convert::From<&RcListResponseCommandsItem> for RcListResponseCommandsItem {
13079 fn from(value: &RcListResponseCommandsItem) -> Self {
13080 value.clone()
13081 }
13082 }
13083
13084 impl ::std::default::Default for RcListResponseCommandsItem {
13085 fn default() -> Self {
13086 Self {
13087 auth_required: Default::default(),
13088 help: Default::default(),
13089 needs_request: Default::default(),
13090 needs_response: Default::default(),
13091 path: Default::default(),
13092 title: Default::default(),
13093 }
13094 }
13095 }
13096
13097 ///`RcNoopAuthRequest`
13098 ///
13099 /// <details><summary>JSON schema</summary>
13100 ///
13101 /// ```json
13102 ///{
13103 /// "type": "object",
13104 /// "properties": {
13105 /// "_async": {
13106 /// "description": "Run the command asynchronously. Returns a job id
13107 /// immediately.",
13108 /// "type": "boolean"
13109 /// }
13110 /// },
13111 /// "additionalProperties": true
13112 ///}
13113 /// ```
13114 /// </details>
13115 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13116 pub struct RcNoopAuthRequest {
13117 ///Run the command asynchronously. Returns a job id immediately.
13118 #[serde(
13119 rename = "_async",
13120 default,
13121 skip_serializing_if = "::std::option::Option::is_none"
13122 )]
13123 pub async_: ::std::option::Option<bool>,
13124 }
13125
13126 impl ::std::convert::From<&RcNoopAuthRequest> for RcNoopAuthRequest {
13127 fn from(value: &RcNoopAuthRequest) -> Self {
13128 value.clone()
13129 }
13130 }
13131
13132 impl ::std::default::Default for RcNoopAuthRequest {
13133 fn default() -> Self {
13134 Self {
13135 async_: Default::default(),
13136 }
13137 }
13138 }
13139
13140 ///`RcNoopRequest`
13141 ///
13142 /// <details><summary>JSON schema</summary>
13143 ///
13144 /// ```json
13145 ///{
13146 /// "type": "object",
13147 /// "properties": {
13148 /// "_async": {
13149 /// "description": "Run the command asynchronously. Returns a job id
13150 /// immediately.",
13151 /// "type": "boolean"
13152 /// }
13153 /// },
13154 /// "additionalProperties": true
13155 ///}
13156 /// ```
13157 /// </details>
13158 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13159 pub struct RcNoopRequest {
13160 ///Run the command asynchronously. Returns a job id immediately.
13161 #[serde(
13162 rename = "_async",
13163 default,
13164 skip_serializing_if = "::std::option::Option::is_none"
13165 )]
13166 pub async_: ::std::option::Option<bool>,
13167 }
13168
13169 impl ::std::convert::From<&RcNoopRequest> for RcNoopRequest {
13170 fn from(value: &RcNoopRequest) -> Self {
13171 value.clone()
13172 }
13173 }
13174
13175 impl ::std::default::Default for RcNoopRequest {
13176 fn default() -> Self {
13177 Self {
13178 async_: Default::default(),
13179 }
13180 }
13181 }
13182
13183 ///`ServeListRequest`
13184 ///
13185 /// <details><summary>JSON schema</summary>
13186 ///
13187 /// ```json
13188 ///{
13189 /// "type": "object",
13190 /// "properties": {
13191 /// "_async": {
13192 /// "description": "Run the command asynchronously. Returns a job id
13193 /// immediately.",
13194 /// "type": "boolean"
13195 /// },
13196 /// "_group": {
13197 /// "description": "Assign the request to a custom stats group.",
13198 /// "type": "string"
13199 /// }
13200 /// }
13201 ///}
13202 /// ```
13203 /// </details>
13204 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13205 pub struct ServeListRequest {
13206 ///Run the command asynchronously. Returns a job id immediately.
13207 #[serde(
13208 rename = "_async",
13209 default,
13210 skip_serializing_if = "::std::option::Option::is_none"
13211 )]
13212 pub async_: ::std::option::Option<bool>,
13213 ///Assign the request to a custom stats group.
13214 #[serde(
13215 rename = "_group",
13216 default,
13217 skip_serializing_if = "::std::option::Option::is_none"
13218 )]
13219 pub group: ::std::option::Option<::std::string::String>,
13220 }
13221
13222 impl ::std::convert::From<&ServeListRequest> for ServeListRequest {
13223 fn from(value: &ServeListRequest) -> Self {
13224 value.clone()
13225 }
13226 }
13227
13228 impl ::std::default::Default for ServeListRequest {
13229 fn default() -> Self {
13230 Self {
13231 async_: Default::default(),
13232 group: Default::default(),
13233 }
13234 }
13235 }
13236
13237 ///`ServeListResponse`
13238 ///
13239 /// <details><summary>JSON schema</summary>
13240 ///
13241 /// ```json
13242 ///{
13243 /// "type": "object",
13244 /// "required": [
13245 /// "list"
13246 /// ],
13247 /// "properties": {
13248 /// "list": {
13249 /// "type": "array",
13250 /// "items": {
13251 /// "type": "object",
13252 /// "required": [
13253 /// "addr",
13254 /// "id"
13255 /// ],
13256 /// "properties": {
13257 /// "addr": {
13258 /// "description": "Address and port the server is listening
13259 /// on.",
13260 /// "type": "string"
13261 /// },
13262 /// "id": {
13263 /// "description": "Identifier returned by `serve/start`.",
13264 /// "type": "string"
13265 /// },
13266 /// "params": {
13267 /// "description": "Serve configuration parameters supplied at
13268 /// startup.",
13269 /// "type": "object",
13270 /// "required": [
13271 /// "fs",
13272 /// "id",
13273 /// "type"
13274 /// ],
13275 /// "properties": {
13276 /// "fs": {
13277 /// "type": "string"
13278 /// },
13279 /// "opt": {
13280 /// "type": "object",
13281 /// "additionalProperties": true
13282 /// },
13283 /// "type": {
13284 /// "type": "string"
13285 /// },
13286 /// "vfsOpt": {
13287 /// "type": "object",
13288 /// "additionalProperties": true
13289 /// }
13290 /// },
13291 /// "additionalProperties": true
13292 /// }
13293 /// },
13294 /// "additionalProperties": false
13295 /// }
13296 /// }
13297 /// }
13298 ///}
13299 /// ```
13300 /// </details>
13301 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13302 pub struct ServeListResponse {
13303 pub list: ::std::vec::Vec<ServeListResponseListItem>,
13304 }
13305
13306 impl ::std::convert::From<&ServeListResponse> for ServeListResponse {
13307 fn from(value: &ServeListResponse) -> Self {
13308 value.clone()
13309 }
13310 }
13311
13312 ///`ServeListResponseListItem`
13313 ///
13314 /// <details><summary>JSON schema</summary>
13315 ///
13316 /// ```json
13317 ///{
13318 /// "type": "object",
13319 /// "required": [
13320 /// "addr",
13321 /// "id"
13322 /// ],
13323 /// "properties": {
13324 /// "addr": {
13325 /// "description": "Address and port the server is listening on.",
13326 /// "type": "string"
13327 /// },
13328 /// "id": {
13329 /// "description": "Identifier returned by `serve/start`.",
13330 /// "type": "string"
13331 /// },
13332 /// "params": {
13333 /// "description": "Serve configuration parameters supplied at
13334 /// startup.",
13335 /// "type": "object",
13336 /// "required": [
13337 /// "fs",
13338 /// "id",
13339 /// "type"
13340 /// ],
13341 /// "properties": {
13342 /// "fs": {
13343 /// "type": "string"
13344 /// },
13345 /// "opt": {
13346 /// "type": "object",
13347 /// "additionalProperties": true
13348 /// },
13349 /// "type": {
13350 /// "type": "string"
13351 /// },
13352 /// "vfsOpt": {
13353 /// "type": "object",
13354 /// "additionalProperties": true
13355 /// }
13356 /// },
13357 /// "additionalProperties": true
13358 /// }
13359 /// },
13360 /// "additionalProperties": false
13361 ///}
13362 /// ```
13363 /// </details>
13364 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13365 #[serde(deny_unknown_fields)]
13366 pub struct ServeListResponseListItem {
13367 ///Address and port the server is listening on.
13368 pub addr: ::std::string::String,
13369 ///Identifier returned by `serve/start`.
13370 pub id: ::std::string::String,
13371 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13372 pub params: ::std::option::Option<ServeListResponseListItemParams>,
13373 }
13374
13375 impl ::std::convert::From<&ServeListResponseListItem> for ServeListResponseListItem {
13376 fn from(value: &ServeListResponseListItem) -> Self {
13377 value.clone()
13378 }
13379 }
13380
13381 ///Serve configuration parameters supplied at startup.
13382 ///
13383 /// <details><summary>JSON schema</summary>
13384 ///
13385 /// ```json
13386 ///{
13387 /// "description": "Serve configuration parameters supplied at startup.",
13388 /// "type": "object",
13389 /// "required": [
13390 /// "fs",
13391 /// "id",
13392 /// "type"
13393 /// ],
13394 /// "properties": {
13395 /// "fs": {
13396 /// "type": "string"
13397 /// },
13398 /// "opt": {
13399 /// "type": "object",
13400 /// "additionalProperties": true
13401 /// },
13402 /// "type": {
13403 /// "type": "string"
13404 /// },
13405 /// "vfsOpt": {
13406 /// "type": "object",
13407 /// "additionalProperties": true
13408 /// }
13409 /// },
13410 /// "additionalProperties": true
13411 ///}
13412 /// ```
13413 /// </details>
13414 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13415 pub struct ServeListResponseListItemParams {
13416 pub fs: ::std::string::String,
13417 pub id: ::serde_json::Value,
13418 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
13419 pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
13420 #[serde(rename = "type")]
13421 pub type_: ::std::string::String,
13422 #[serde(
13423 rename = "vfsOpt",
13424 default,
13425 skip_serializing_if = "::serde_json::Map::is_empty"
13426 )]
13427 pub vfs_opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
13428 }
13429
13430 impl ::std::convert::From<&ServeListResponseListItemParams> for ServeListResponseListItemParams {
13431 fn from(value: &ServeListResponseListItemParams) -> Self {
13432 value.clone()
13433 }
13434 }
13435
13436 ///`ServeStartRequest`
13437 ///
13438 /// <details><summary>JSON schema</summary>
13439 ///
13440 /// ```json
13441 ///{
13442 /// "type": "object",
13443 /// "properties": {
13444 /// "_async": {
13445 /// "description": "Run the command asynchronously. Returns a job id
13446 /// immediately.",
13447 /// "type": "boolean"
13448 /// },
13449 /// "_config": {
13450 /// "description": "JSON encoded config overrides applied for this call
13451 /// only.",
13452 /// "type": "string"
13453 /// },
13454 /// "_filter": {
13455 /// "description": "JSON encoded filter overrides applied for this call
13456 /// only.",
13457 /// "type": "string"
13458 /// },
13459 /// "_group": {
13460 /// "description": "Assign the request to a custom stats group.",
13461 /// "type": "string"
13462 /// },
13463 /// "addr": {
13464 /// "description": "Address and port to bind the server to, such as
13465 /// `:5572` or `localhost:8080`.",
13466 /// "type": "string"
13467 /// },
13468 /// "fs": {
13469 /// "description": "Remote path that will be served.",
13470 /// "type": "string"
13471 /// },
13472 /// "type": {
13473 /// "description": "Type of server to start (e.g. `http`, `webdav`,
13474 /// `ftp`, `sftp`).",
13475 /// "type": "string"
13476 /// }
13477 /// },
13478 /// "additionalProperties": true
13479 ///}
13480 /// ```
13481 /// </details>
13482 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13483 pub struct ServeStartRequest {
13484 ///Address and port to bind the server to, such as `:5572` or
13485 /// `localhost:8080`.
13486 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13487 pub addr: ::std::option::Option<::std::string::String>,
13488 ///Run the command asynchronously. Returns a job id immediately.
13489 #[serde(
13490 rename = "_async",
13491 default,
13492 skip_serializing_if = "::std::option::Option::is_none"
13493 )]
13494 pub async_: ::std::option::Option<bool>,
13495 ///JSON encoded config overrides applied for this call only.
13496 #[serde(
13497 rename = "_config",
13498 default,
13499 skip_serializing_if = "::std::option::Option::is_none"
13500 )]
13501 pub config: ::std::option::Option<::std::string::String>,
13502 ///JSON encoded filter overrides applied for this call only.
13503 #[serde(
13504 rename = "_filter",
13505 default,
13506 skip_serializing_if = "::std::option::Option::is_none"
13507 )]
13508 pub filter: ::std::option::Option<::std::string::String>,
13509 ///Remote path that will be served.
13510 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13511 pub fs: ::std::option::Option<::std::string::String>,
13512 ///Assign the request to a custom stats group.
13513 #[serde(
13514 rename = "_group",
13515 default,
13516 skip_serializing_if = "::std::option::Option::is_none"
13517 )]
13518 pub group: ::std::option::Option<::std::string::String>,
13519 ///Type of server to start (e.g. `http`, `webdav`, `ftp`, `sftp`).
13520 #[serde(
13521 rename = "type",
13522 default,
13523 skip_serializing_if = "::std::option::Option::is_none"
13524 )]
13525 pub type_: ::std::option::Option<::std::string::String>,
13526 }
13527
13528 impl ::std::convert::From<&ServeStartRequest> for ServeStartRequest {
13529 fn from(value: &ServeStartRequest) -> Self {
13530 value.clone()
13531 }
13532 }
13533
13534 impl ::std::default::Default for ServeStartRequest {
13535 fn default() -> Self {
13536 Self {
13537 addr: Default::default(),
13538 async_: Default::default(),
13539 config: Default::default(),
13540 filter: Default::default(),
13541 fs: Default::default(),
13542 group: Default::default(),
13543 type_: Default::default(),
13544 }
13545 }
13546 }
13547
13548 ///`ServeStartResponse`
13549 ///
13550 /// <details><summary>JSON schema</summary>
13551 ///
13552 /// ```json
13553 ///{
13554 /// "type": "object",
13555 /// "required": [
13556 /// "addr",
13557 /// "id"
13558 /// ],
13559 /// "properties": {
13560 /// "addr": {
13561 /// "description": "Address and port the server is listening on.",
13562 /// "type": "string"
13563 /// },
13564 /// "id": {
13565 /// "description": "Identifier to pass to `serve/stop`.",
13566 /// "type": "string"
13567 /// }
13568 /// }
13569 ///}
13570 /// ```
13571 /// </details>
13572 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13573 pub struct ServeStartResponse {
13574 ///Address and port the server is listening on.
13575 pub addr: ::std::string::String,
13576 ///Identifier to pass to `serve/stop`.
13577 pub id: ::std::string::String,
13578 }
13579
13580 impl ::std::convert::From<&ServeStartResponse> for ServeStartResponse {
13581 fn from(value: &ServeStartResponse) -> Self {
13582 value.clone()
13583 }
13584 }
13585
13586 ///`ServeStopRequest`
13587 ///
13588 /// <details><summary>JSON schema</summary>
13589 ///
13590 /// ```json
13591 ///{
13592 /// "type": "object",
13593 /// "properties": {
13594 /// "_async": {
13595 /// "description": "Run the command asynchronously. Returns a job id
13596 /// immediately.",
13597 /// "type": "boolean"
13598 /// },
13599 /// "_group": {
13600 /// "description": "Assign the request to a custom stats group.",
13601 /// "type": "string"
13602 /// },
13603 /// "id": {
13604 /// "description": "Identifier of the running serve instance returned
13605 /// by `serve/start`.",
13606 /// "type": "string"
13607 /// }
13608 /// }
13609 ///}
13610 /// ```
13611 /// </details>
13612 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13613 pub struct ServeStopRequest {
13614 ///Run the command asynchronously. Returns a job id immediately.
13615 #[serde(
13616 rename = "_async",
13617 default,
13618 skip_serializing_if = "::std::option::Option::is_none"
13619 )]
13620 pub async_: ::std::option::Option<bool>,
13621 ///Assign the request to a custom stats group.
13622 #[serde(
13623 rename = "_group",
13624 default,
13625 skip_serializing_if = "::std::option::Option::is_none"
13626 )]
13627 pub group: ::std::option::Option<::std::string::String>,
13628 ///Identifier of the running serve instance returned by `serve/start`.
13629 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13630 pub id: ::std::option::Option<::std::string::String>,
13631 }
13632
13633 impl ::std::convert::From<&ServeStopRequest> for ServeStopRequest {
13634 fn from(value: &ServeStopRequest) -> Self {
13635 value.clone()
13636 }
13637 }
13638
13639 impl ::std::default::Default for ServeStopRequest {
13640 fn default() -> Self {
13641 Self {
13642 async_: Default::default(),
13643 group: Default::default(),
13644 id: Default::default(),
13645 }
13646 }
13647 }
13648
13649 ///`ServeStopResponse`
13650 ///
13651 /// <details><summary>JSON schema</summary>
13652 ///
13653 /// ```json
13654 ///{
13655 /// "type": "object",
13656 /// "properties": {
13657 /// "jobid": {
13658 /// "description": "Job ID returned when _async=true.",
13659 /// "type": "integer"
13660 /// }
13661 /// },
13662 /// "additionalProperties": true
13663 ///}
13664 /// ```
13665 /// </details>
13666 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13667 pub struct ServeStopResponse {
13668 ///Job ID returned when _async=true.
13669 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13670 pub jobid: ::std::option::Option<i64>,
13671 }
13672
13673 impl ::std::convert::From<&ServeStopResponse> for ServeStopResponse {
13674 fn from(value: &ServeStopResponse) -> Self {
13675 value.clone()
13676 }
13677 }
13678
13679 impl ::std::default::Default for ServeStopResponse {
13680 fn default() -> Self {
13681 Self {
13682 jobid: Default::default(),
13683 }
13684 }
13685 }
13686
13687 ///`ServeStopallRequest`
13688 ///
13689 /// <details><summary>JSON schema</summary>
13690 ///
13691 /// ```json
13692 ///{
13693 /// "type": "object",
13694 /// "properties": {
13695 /// "_async": {
13696 /// "description": "Run the command asynchronously. Returns a job id
13697 /// immediately.",
13698 /// "type": "boolean"
13699 /// },
13700 /// "_group": {
13701 /// "description": "Assign the request to a custom stats group.",
13702 /// "type": "string"
13703 /// }
13704 /// }
13705 ///}
13706 /// ```
13707 /// </details>
13708 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13709 pub struct ServeStopallRequest {
13710 ///Run the command asynchronously. Returns a job id immediately.
13711 #[serde(
13712 rename = "_async",
13713 default,
13714 skip_serializing_if = "::std::option::Option::is_none"
13715 )]
13716 pub async_: ::std::option::Option<bool>,
13717 ///Assign the request to a custom stats group.
13718 #[serde(
13719 rename = "_group",
13720 default,
13721 skip_serializing_if = "::std::option::Option::is_none"
13722 )]
13723 pub group: ::std::option::Option<::std::string::String>,
13724 }
13725
13726 impl ::std::convert::From<&ServeStopallRequest> for ServeStopallRequest {
13727 fn from(value: &ServeStopallRequest) -> Self {
13728 value.clone()
13729 }
13730 }
13731
13732 impl ::std::default::Default for ServeStopallRequest {
13733 fn default() -> Self {
13734 Self {
13735 async_: Default::default(),
13736 group: Default::default(),
13737 }
13738 }
13739 }
13740
13741 ///`ServeStopallResponse`
13742 ///
13743 /// <details><summary>JSON schema</summary>
13744 ///
13745 /// ```json
13746 ///{
13747 /// "type": "object",
13748 /// "properties": {
13749 /// "jobid": {
13750 /// "description": "Job ID returned when _async=true.",
13751 /// "type": "integer"
13752 /// }
13753 /// },
13754 /// "additionalProperties": true
13755 ///}
13756 /// ```
13757 /// </details>
13758 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13759 pub struct ServeStopallResponse {
13760 ///Job ID returned when _async=true.
13761 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13762 pub jobid: ::std::option::Option<i64>,
13763 }
13764
13765 impl ::std::convert::From<&ServeStopallResponse> for ServeStopallResponse {
13766 fn from(value: &ServeStopallResponse) -> Self {
13767 value.clone()
13768 }
13769 }
13770
13771 impl ::std::default::Default for ServeStopallResponse {
13772 fn default() -> Self {
13773 Self {
13774 jobid: Default::default(),
13775 }
13776 }
13777 }
13778
13779 ///`ServeTypesRequest`
13780 ///
13781 /// <details><summary>JSON schema</summary>
13782 ///
13783 /// ```json
13784 ///{
13785 /// "type": "object",
13786 /// "properties": {
13787 /// "_async": {
13788 /// "description": "Run the command asynchronously. Returns a job id
13789 /// immediately.",
13790 /// "type": "boolean"
13791 /// },
13792 /// "_group": {
13793 /// "description": "Assign the request to a custom stats group.",
13794 /// "type": "string"
13795 /// }
13796 /// }
13797 ///}
13798 /// ```
13799 /// </details>
13800 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13801 pub struct ServeTypesRequest {
13802 ///Run the command asynchronously. Returns a job id immediately.
13803 #[serde(
13804 rename = "_async",
13805 default,
13806 skip_serializing_if = "::std::option::Option::is_none"
13807 )]
13808 pub async_: ::std::option::Option<bool>,
13809 ///Assign the request to a custom stats group.
13810 #[serde(
13811 rename = "_group",
13812 default,
13813 skip_serializing_if = "::std::option::Option::is_none"
13814 )]
13815 pub group: ::std::option::Option<::std::string::String>,
13816 }
13817
13818 impl ::std::convert::From<&ServeTypesRequest> for ServeTypesRequest {
13819 fn from(value: &ServeTypesRequest) -> Self {
13820 value.clone()
13821 }
13822 }
13823
13824 impl ::std::default::Default for ServeTypesRequest {
13825 fn default() -> Self {
13826 Self {
13827 async_: Default::default(),
13828 group: Default::default(),
13829 }
13830 }
13831 }
13832
13833 ///`ServeTypesResponse`
13834 ///
13835 /// <details><summary>JSON schema</summary>
13836 ///
13837 /// ```json
13838 ///{
13839 /// "type": "object",
13840 /// "required": [
13841 /// "types"
13842 /// ],
13843 /// "properties": {
13844 /// "types": {
13845 /// "type": "array",
13846 /// "items": {
13847 /// "type": "string"
13848 /// }
13849 /// }
13850 /// }
13851 ///}
13852 /// ```
13853 /// </details>
13854 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13855 pub struct ServeTypesResponse {
13856 pub types: ::std::vec::Vec<::std::string::String>,
13857 }
13858
13859 impl ::std::convert::From<&ServeTypesResponse> for ServeTypesResponse {
13860 fn from(value: &ServeTypesResponse) -> Self {
13861 value.clone()
13862 }
13863 }
13864
13865 ///`SyncBisyncRequest`
13866 ///
13867 /// <details><summary>JSON schema</summary>
13868 ///
13869 /// ```json
13870 ///{
13871 /// "type": "object",
13872 /// "properties": {
13873 /// "_async": {
13874 /// "description": "Run the command asynchronously. Returns a job id
13875 /// immediately.",
13876 /// "type": "boolean"
13877 /// },
13878 /// "_config": {
13879 /// "description": "JSON encoded config overrides applied for this call
13880 /// only.",
13881 /// "type": "string"
13882 /// },
13883 /// "_filter": {
13884 /// "description": "JSON encoded filter overrides applied for this call
13885 /// only.",
13886 /// "type": "string"
13887 /// },
13888 /// "_group": {
13889 /// "description": "Assign the request to a custom stats group.",
13890 /// "type": "string"
13891 /// },
13892 /// "backupdir1": {
13893 /// "description": "Backup directory on the first remote for changed
13894 /// files.",
13895 /// "type": "string"
13896 /// },
13897 /// "backupdir2": {
13898 /// "description": "Backup directory on the second remote for changed
13899 /// files.",
13900 /// "type": "string"
13901 /// },
13902 /// "checkAccess": {
13903 /// "description": "Set to true to abort if `RCLONE_TEST` files are
13904 /// missing on either side.",
13905 /// "type": "boolean"
13906 /// },
13907 /// "checkFilename": {
13908 /// "description": "Override the access-check sentinel filename;
13909 /// defaults to `RCLONE_TEST`.",
13910 /// "type": "string"
13911 /// },
13912 /// "checkSync": {
13913 /// "description": "Controls final listing comparison; leave true for
13914 /// normal verification or set false to skip.",
13915 /// "type": "boolean"
13916 /// },
13917 /// "createEmptySrcDirs": {
13918 /// "description": "Set to true to mirror empty directories between the
13919 /// two paths.",
13920 /// "type": "boolean"
13921 /// },
13922 /// "dryRun": {
13923 /// "description": "Set to true to simulate the bisync run without
13924 /// making changes.",
13925 /// "type": "boolean"
13926 /// },
13927 /// "filtersFile": {
13928 /// "description": "Path to an rclone filters file applied to both
13929 /// paths.",
13930 /// "type": "string"
13931 /// },
13932 /// "force": {
13933 /// "description": "Set to true to bypass the `maxDelete` safety
13934 /// check.",
13935 /// "type": "boolean"
13936 /// },
13937 /// "ignoreListingChecksum": {
13938 /// "description": "Set to true to ignore checksum differences when
13939 /// comparing listings.",
13940 /// "type": "boolean"
13941 /// },
13942 /// "maxDelete": {
13943 /// "description": "Abort the run if deletions exceed this percentage
13944 /// (default 50).",
13945 /// "type": "number"
13946 /// },
13947 /// "noCleanup": {
13948 /// "description": "Set to true to keep bisync working files after
13949 /// completion.",
13950 /// "type": "boolean"
13951 /// },
13952 /// "path1": {
13953 /// "description": "First remote directory, e.g. `drive:path1`.",
13954 /// "type": "string"
13955 /// },
13956 /// "path2": {
13957 /// "description": "Second remote directory, e.g. `drive:path2`.",
13958 /// "type": "string"
13959 /// },
13960 /// "removeEmptyDirs": {
13961 /// "description": "Set to true to remove empty directories during
13962 /// cleanup.",
13963 /// "type": "boolean"
13964 /// },
13965 /// "resilient": {
13966 /// "description": "Set to true to allow retrying after certain
13967 /// recoverable errors.",
13968 /// "type": "boolean"
13969 /// },
13970 /// "resync": {
13971 /// "description": "Set to true to perform a one-time resync,
13972 /// rebuilding bisync history.",
13973 /// "type": "boolean"
13974 /// },
13975 /// "workdir": {
13976 /// "description": "Directory path used to store bisync working
13977 /// files.",
13978 /// "type": "string"
13979 /// }
13980 /// }
13981 ///}
13982 /// ```
13983 /// </details>
13984 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13985 pub struct SyncBisyncRequest {
13986 ///Run the command asynchronously. Returns a job id immediately.
13987 #[serde(
13988 rename = "_async",
13989 default,
13990 skip_serializing_if = "::std::option::Option::is_none"
13991 )]
13992 pub async_: ::std::option::Option<bool>,
13993 ///Backup directory on the first remote for changed files.
13994 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13995 pub backupdir1: ::std::option::Option<::std::string::String>,
13996 ///Backup directory on the second remote for changed files.
13997 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13998 pub backupdir2: ::std::option::Option<::std::string::String>,
13999 ///Set to true to abort if `RCLONE_TEST` files are missing on either
14000 /// side.
14001 #[serde(
14002 rename = "checkAccess",
14003 default,
14004 skip_serializing_if = "::std::option::Option::is_none"
14005 )]
14006 pub check_access: ::std::option::Option<bool>,
14007 ///Override the access-check sentinel filename; defaults to
14008 /// `RCLONE_TEST`.
14009 #[serde(
14010 rename = "checkFilename",
14011 default,
14012 skip_serializing_if = "::std::option::Option::is_none"
14013 )]
14014 pub check_filename: ::std::option::Option<::std::string::String>,
14015 ///Controls final listing comparison; leave true for normal
14016 /// verification or set false to skip.
14017 #[serde(
14018 rename = "checkSync",
14019 default,
14020 skip_serializing_if = "::std::option::Option::is_none"
14021 )]
14022 pub check_sync: ::std::option::Option<bool>,
14023 ///JSON encoded config overrides applied for this call only.
14024 #[serde(
14025 rename = "_config",
14026 default,
14027 skip_serializing_if = "::std::option::Option::is_none"
14028 )]
14029 pub config: ::std::option::Option<::std::string::String>,
14030 ///Set to true to mirror empty directories between the two paths.
14031 #[serde(
14032 rename = "createEmptySrcDirs",
14033 default,
14034 skip_serializing_if = "::std::option::Option::is_none"
14035 )]
14036 pub create_empty_src_dirs: ::std::option::Option<bool>,
14037 ///Set to true to simulate the bisync run without making changes.
14038 #[serde(
14039 rename = "dryRun",
14040 default,
14041 skip_serializing_if = "::std::option::Option::is_none"
14042 )]
14043 pub dry_run: ::std::option::Option<bool>,
14044 ///JSON encoded filter overrides applied for this call only.
14045 #[serde(
14046 rename = "_filter",
14047 default,
14048 skip_serializing_if = "::std::option::Option::is_none"
14049 )]
14050 pub filter: ::std::option::Option<::std::string::String>,
14051 ///Path to an rclone filters file applied to both paths.
14052 #[serde(
14053 rename = "filtersFile",
14054 default,
14055 skip_serializing_if = "::std::option::Option::is_none"
14056 )]
14057 pub filters_file: ::std::option::Option<::std::string::String>,
14058 ///Set to true to bypass the `maxDelete` safety check.
14059 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14060 pub force: ::std::option::Option<bool>,
14061 ///Assign the request to a custom stats group.
14062 #[serde(
14063 rename = "_group",
14064 default,
14065 skip_serializing_if = "::std::option::Option::is_none"
14066 )]
14067 pub group: ::std::option::Option<::std::string::String>,
14068 ///Set to true to ignore checksum differences when comparing listings.
14069 #[serde(
14070 rename = "ignoreListingChecksum",
14071 default,
14072 skip_serializing_if = "::std::option::Option::is_none"
14073 )]
14074 pub ignore_listing_checksum: ::std::option::Option<bool>,
14075 #[serde(
14076 rename = "maxDelete",
14077 default,
14078 skip_serializing_if = "::std::option::Option::is_none"
14079 )]
14080 pub max_delete: ::std::option::Option<f64>,
14081 ///Set to true to keep bisync working files after completion.
14082 #[serde(
14083 rename = "noCleanup",
14084 default,
14085 skip_serializing_if = "::std::option::Option::is_none"
14086 )]
14087 pub no_cleanup: ::std::option::Option<bool>,
14088 ///First remote directory, e.g. `drive:path1`.
14089 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14090 pub path1: ::std::option::Option<::std::string::String>,
14091 ///Second remote directory, e.g. `drive:path2`.
14092 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14093 pub path2: ::std::option::Option<::std::string::String>,
14094 ///Set to true to remove empty directories during cleanup.
14095 #[serde(
14096 rename = "removeEmptyDirs",
14097 default,
14098 skip_serializing_if = "::std::option::Option::is_none"
14099 )]
14100 pub remove_empty_dirs: ::std::option::Option<bool>,
14101 ///Set to true to allow retrying after certain recoverable errors.
14102 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14103 pub resilient: ::std::option::Option<bool>,
14104 ///Set to true to perform a one-time resync, rebuilding bisync history.
14105 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14106 pub resync: ::std::option::Option<bool>,
14107 ///Directory path used to store bisync working files.
14108 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14109 pub workdir: ::std::option::Option<::std::string::String>,
14110 }
14111
14112 impl ::std::convert::From<&SyncBisyncRequest> for SyncBisyncRequest {
14113 fn from(value: &SyncBisyncRequest) -> Self {
14114 value.clone()
14115 }
14116 }
14117
14118 impl ::std::default::Default for SyncBisyncRequest {
14119 fn default() -> Self {
14120 Self {
14121 async_: Default::default(),
14122 backupdir1: Default::default(),
14123 backupdir2: Default::default(),
14124 check_access: Default::default(),
14125 check_filename: Default::default(),
14126 check_sync: Default::default(),
14127 config: Default::default(),
14128 create_empty_src_dirs: Default::default(),
14129 dry_run: Default::default(),
14130 filter: Default::default(),
14131 filters_file: Default::default(),
14132 force: Default::default(),
14133 group: Default::default(),
14134 ignore_listing_checksum: Default::default(),
14135 max_delete: Default::default(),
14136 no_cleanup: Default::default(),
14137 path1: Default::default(),
14138 path2: Default::default(),
14139 remove_empty_dirs: Default::default(),
14140 resilient: Default::default(),
14141 resync: Default::default(),
14142 workdir: Default::default(),
14143 }
14144 }
14145 }
14146
14147 ///`SyncBisyncResponse`
14148 ///
14149 /// <details><summary>JSON schema</summary>
14150 ///
14151 /// ```json
14152 ///{
14153 /// "type": "object",
14154 /// "properties": {
14155 /// "jobid": {
14156 /// "description": "Job ID of the operation.",
14157 /// "type": "integer"
14158 /// }
14159 /// }
14160 ///}
14161 /// ```
14162 /// </details>
14163 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14164 pub struct SyncBisyncResponse {
14165 ///Job ID of the operation.
14166 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14167 pub jobid: ::std::option::Option<i64>,
14168 }
14169
14170 impl ::std::convert::From<&SyncBisyncResponse> for SyncBisyncResponse {
14171 fn from(value: &SyncBisyncResponse) -> Self {
14172 value.clone()
14173 }
14174 }
14175
14176 impl ::std::default::Default for SyncBisyncResponse {
14177 fn default() -> Self {
14178 Self {
14179 jobid: Default::default(),
14180 }
14181 }
14182 }
14183
14184 ///`SyncCopyRequest`
14185 ///
14186 /// <details><summary>JSON schema</summary>
14187 ///
14188 /// ```json
14189 ///{
14190 /// "type": "object",
14191 /// "properties": {
14192 /// "_async": {
14193 /// "description": "Run the command asynchronously. Returns a job id
14194 /// immediately.",
14195 /// "type": "boolean"
14196 /// },
14197 /// "_config": {
14198 /// "description": "JSON encoded config overrides applied for this call
14199 /// only.",
14200 /// "type": "string"
14201 /// },
14202 /// "_filter": {
14203 /// "description": "JSON encoded filter overrides applied for this call
14204 /// only.",
14205 /// "type": "string"
14206 /// },
14207 /// "_group": {
14208 /// "description": "Assign the request to a custom stats group.",
14209 /// "type": "string"
14210 /// },
14211 /// "createEmptySrcDirs": {
14212 /// "description": "Set to true to replicate empty source directories
14213 /// on the destination.",
14214 /// "type": "boolean"
14215 /// },
14216 /// "dstFs": {
14217 /// "description": "Destination remote path to copy to.",
14218 /// "type": "string"
14219 /// },
14220 /// "srcFs": {
14221 /// "description": "Source remote path to copy from.",
14222 /// "type": "string"
14223 /// }
14224 /// }
14225 ///}
14226 /// ```
14227 /// </details>
14228 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14229 pub struct SyncCopyRequest {
14230 ///Run the command asynchronously. Returns a job id immediately.
14231 #[serde(
14232 rename = "_async",
14233 default,
14234 skip_serializing_if = "::std::option::Option::is_none"
14235 )]
14236 pub async_: ::std::option::Option<bool>,
14237 ///JSON encoded config overrides applied for this call only.
14238 #[serde(
14239 rename = "_config",
14240 default,
14241 skip_serializing_if = "::std::option::Option::is_none"
14242 )]
14243 pub config: ::std::option::Option<::std::string::String>,
14244 ///Set to true to replicate empty source directories on the
14245 /// destination.
14246 #[serde(
14247 rename = "createEmptySrcDirs",
14248 default,
14249 skip_serializing_if = "::std::option::Option::is_none"
14250 )]
14251 pub create_empty_src_dirs: ::std::option::Option<bool>,
14252 ///Destination remote path to copy to.
14253 #[serde(
14254 rename = "dstFs",
14255 default,
14256 skip_serializing_if = "::std::option::Option::is_none"
14257 )]
14258 pub dst_fs: ::std::option::Option<::std::string::String>,
14259 ///JSON encoded filter overrides applied for this call only.
14260 #[serde(
14261 rename = "_filter",
14262 default,
14263 skip_serializing_if = "::std::option::Option::is_none"
14264 )]
14265 pub filter: ::std::option::Option<::std::string::String>,
14266 ///Assign the request to a custom stats group.
14267 #[serde(
14268 rename = "_group",
14269 default,
14270 skip_serializing_if = "::std::option::Option::is_none"
14271 )]
14272 pub group: ::std::option::Option<::std::string::String>,
14273 ///Source remote path to copy from.
14274 #[serde(
14275 rename = "srcFs",
14276 default,
14277 skip_serializing_if = "::std::option::Option::is_none"
14278 )]
14279 pub src_fs: ::std::option::Option<::std::string::String>,
14280 }
14281
14282 impl ::std::convert::From<&SyncCopyRequest> for SyncCopyRequest {
14283 fn from(value: &SyncCopyRequest) -> Self {
14284 value.clone()
14285 }
14286 }
14287
14288 impl ::std::default::Default for SyncCopyRequest {
14289 fn default() -> Self {
14290 Self {
14291 async_: Default::default(),
14292 config: Default::default(),
14293 create_empty_src_dirs: Default::default(),
14294 dst_fs: Default::default(),
14295 filter: Default::default(),
14296 group: Default::default(),
14297 src_fs: Default::default(),
14298 }
14299 }
14300 }
14301
14302 ///`SyncCopyResponse`
14303 ///
14304 /// <details><summary>JSON schema</summary>
14305 ///
14306 /// ```json
14307 ///{
14308 /// "type": "object",
14309 /// "properties": {
14310 /// "jobid": {
14311 /// "description": "Job ID of the operation.",
14312 /// "type": "integer"
14313 /// }
14314 /// }
14315 ///}
14316 /// ```
14317 /// </details>
14318 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14319 pub struct SyncCopyResponse {
14320 ///Job ID of the operation.
14321 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14322 pub jobid: ::std::option::Option<i64>,
14323 }
14324
14325 impl ::std::convert::From<&SyncCopyResponse> for SyncCopyResponse {
14326 fn from(value: &SyncCopyResponse) -> Self {
14327 value.clone()
14328 }
14329 }
14330
14331 impl ::std::default::Default for SyncCopyResponse {
14332 fn default() -> Self {
14333 Self {
14334 jobid: Default::default(),
14335 }
14336 }
14337 }
14338
14339 ///`SyncMoveRequest`
14340 ///
14341 /// <details><summary>JSON schema</summary>
14342 ///
14343 /// ```json
14344 ///{
14345 /// "type": "object",
14346 /// "properties": {
14347 /// "_async": {
14348 /// "description": "Run the command asynchronously. Returns a job id
14349 /// immediately.",
14350 /// "type": "boolean"
14351 /// },
14352 /// "_config": {
14353 /// "description": "JSON encoded config overrides applied for this call
14354 /// only.",
14355 /// "type": "string"
14356 /// },
14357 /// "_filter": {
14358 /// "description": "JSON encoded filter overrides applied for this call
14359 /// only.",
14360 /// "type": "string"
14361 /// },
14362 /// "_group": {
14363 /// "description": "Assign the request to a custom stats group.",
14364 /// "type": "string"
14365 /// },
14366 /// "createEmptySrcDirs": {
14367 /// "description": "Set to true to create empty source directories on
14368 /// the destination.",
14369 /// "type": "boolean"
14370 /// },
14371 /// "deleteEmptySrcDirs": {
14372 /// "description": "Set to true to delete empty directories from the
14373 /// source after the move completes.",
14374 /// "type": "boolean"
14375 /// },
14376 /// "dstFs": {
14377 /// "description": "Destination remote path that will receive moved
14378 /// files.",
14379 /// "type": "string"
14380 /// },
14381 /// "srcFs": {
14382 /// "description": "Source remote path whose contents will be moved.",
14383 /// "type": "string"
14384 /// }
14385 /// }
14386 ///}
14387 /// ```
14388 /// </details>
14389 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14390 pub struct SyncMoveRequest {
14391 ///Run the command asynchronously. Returns a job id immediately.
14392 #[serde(
14393 rename = "_async",
14394 default,
14395 skip_serializing_if = "::std::option::Option::is_none"
14396 )]
14397 pub async_: ::std::option::Option<bool>,
14398 ///JSON encoded config overrides applied for this call only.
14399 #[serde(
14400 rename = "_config",
14401 default,
14402 skip_serializing_if = "::std::option::Option::is_none"
14403 )]
14404 pub config: ::std::option::Option<::std::string::String>,
14405 ///Set to true to create empty source directories on the destination.
14406 #[serde(
14407 rename = "createEmptySrcDirs",
14408 default,
14409 skip_serializing_if = "::std::option::Option::is_none"
14410 )]
14411 pub create_empty_src_dirs: ::std::option::Option<bool>,
14412 ///Set to true to delete empty directories from the source after the
14413 /// move completes.
14414 #[serde(
14415 rename = "deleteEmptySrcDirs",
14416 default,
14417 skip_serializing_if = "::std::option::Option::is_none"
14418 )]
14419 pub delete_empty_src_dirs: ::std::option::Option<bool>,
14420 ///Destination remote path that will receive moved files.
14421 #[serde(
14422 rename = "dstFs",
14423 default,
14424 skip_serializing_if = "::std::option::Option::is_none"
14425 )]
14426 pub dst_fs: ::std::option::Option<::std::string::String>,
14427 ///JSON encoded filter overrides applied for this call only.
14428 #[serde(
14429 rename = "_filter",
14430 default,
14431 skip_serializing_if = "::std::option::Option::is_none"
14432 )]
14433 pub filter: ::std::option::Option<::std::string::String>,
14434 ///Assign the request to a custom stats group.
14435 #[serde(
14436 rename = "_group",
14437 default,
14438 skip_serializing_if = "::std::option::Option::is_none"
14439 )]
14440 pub group: ::std::option::Option<::std::string::String>,
14441 ///Source remote path whose contents will be moved.
14442 #[serde(
14443 rename = "srcFs",
14444 default,
14445 skip_serializing_if = "::std::option::Option::is_none"
14446 )]
14447 pub src_fs: ::std::option::Option<::std::string::String>,
14448 }
14449
14450 impl ::std::convert::From<&SyncMoveRequest> for SyncMoveRequest {
14451 fn from(value: &SyncMoveRequest) -> Self {
14452 value.clone()
14453 }
14454 }
14455
14456 impl ::std::default::Default for SyncMoveRequest {
14457 fn default() -> Self {
14458 Self {
14459 async_: Default::default(),
14460 config: Default::default(),
14461 create_empty_src_dirs: Default::default(),
14462 delete_empty_src_dirs: Default::default(),
14463 dst_fs: Default::default(),
14464 filter: Default::default(),
14465 group: Default::default(),
14466 src_fs: Default::default(),
14467 }
14468 }
14469 }
14470
14471 ///`SyncMoveResponse`
14472 ///
14473 /// <details><summary>JSON schema</summary>
14474 ///
14475 /// ```json
14476 ///{
14477 /// "type": "object",
14478 /// "properties": {
14479 /// "jobid": {
14480 /// "description": "Job ID of the operation.",
14481 /// "type": "integer"
14482 /// }
14483 /// }
14484 ///}
14485 /// ```
14486 /// </details>
14487 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14488 pub struct SyncMoveResponse {
14489 ///Job ID of the operation.
14490 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14491 pub jobid: ::std::option::Option<i64>,
14492 }
14493
14494 impl ::std::convert::From<&SyncMoveResponse> for SyncMoveResponse {
14495 fn from(value: &SyncMoveResponse) -> Self {
14496 value.clone()
14497 }
14498 }
14499
14500 impl ::std::default::Default for SyncMoveResponse {
14501 fn default() -> Self {
14502 Self {
14503 jobid: Default::default(),
14504 }
14505 }
14506 }
14507
14508 ///`SyncSyncRequest`
14509 ///
14510 /// <details><summary>JSON schema</summary>
14511 ///
14512 /// ```json
14513 ///{
14514 /// "type": "object",
14515 /// "properties": {
14516 /// "_async": {
14517 /// "description": "Run the command asynchronously. Returns a job id
14518 /// immediately.",
14519 /// "type": "boolean"
14520 /// },
14521 /// "_config": {
14522 /// "description": "JSON encoded config overrides applied for this call
14523 /// only.",
14524 /// "type": "string"
14525 /// },
14526 /// "_filter": {
14527 /// "description": "JSON encoded filter overrides applied for this call
14528 /// only.",
14529 /// "type": "string"
14530 /// },
14531 /// "_group": {
14532 /// "description": "Assign the request to a custom stats group.",
14533 /// "type": "string"
14534 /// },
14535 /// "createEmptySrcDirs": {
14536 /// "description": "Set to true to create empty source directories on
14537 /// the destination.",
14538 /// "type": "boolean"
14539 /// },
14540 /// "dstFs": {
14541 /// "description": "Destination remote path to sync to, e.g.
14542 /// `drive:dst`.",
14543 /// "type": "string"
14544 /// },
14545 /// "srcFs": {
14546 /// "description": "Source remote path to sync from, e.g.
14547 /// `drive:src`.",
14548 /// "type": "string"
14549 /// }
14550 /// }
14551 ///}
14552 /// ```
14553 /// </details>
14554 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14555 pub struct SyncSyncRequest {
14556 ///Run the command asynchronously. Returns a job id immediately.
14557 #[serde(
14558 rename = "_async",
14559 default,
14560 skip_serializing_if = "::std::option::Option::is_none"
14561 )]
14562 pub async_: ::std::option::Option<bool>,
14563 ///JSON encoded config overrides applied for this call only.
14564 #[serde(
14565 rename = "_config",
14566 default,
14567 skip_serializing_if = "::std::option::Option::is_none"
14568 )]
14569 pub config: ::std::option::Option<::std::string::String>,
14570 ///Set to true to create empty source directories on the destination.
14571 #[serde(
14572 rename = "createEmptySrcDirs",
14573 default,
14574 skip_serializing_if = "::std::option::Option::is_none"
14575 )]
14576 pub create_empty_src_dirs: ::std::option::Option<bool>,
14577 ///Destination remote path to sync to, e.g. `drive:dst`.
14578 #[serde(
14579 rename = "dstFs",
14580 default,
14581 skip_serializing_if = "::std::option::Option::is_none"
14582 )]
14583 pub dst_fs: ::std::option::Option<::std::string::String>,
14584 ///JSON encoded filter overrides applied for this call only.
14585 #[serde(
14586 rename = "_filter",
14587 default,
14588 skip_serializing_if = "::std::option::Option::is_none"
14589 )]
14590 pub filter: ::std::option::Option<::std::string::String>,
14591 ///Assign the request to a custom stats group.
14592 #[serde(
14593 rename = "_group",
14594 default,
14595 skip_serializing_if = "::std::option::Option::is_none"
14596 )]
14597 pub group: ::std::option::Option<::std::string::String>,
14598 ///Source remote path to sync from, e.g. `drive:src`.
14599 #[serde(
14600 rename = "srcFs",
14601 default,
14602 skip_serializing_if = "::std::option::Option::is_none"
14603 )]
14604 pub src_fs: ::std::option::Option<::std::string::String>,
14605 }
14606
14607 impl ::std::convert::From<&SyncSyncRequest> for SyncSyncRequest {
14608 fn from(value: &SyncSyncRequest) -> Self {
14609 value.clone()
14610 }
14611 }
14612
14613 impl ::std::default::Default for SyncSyncRequest {
14614 fn default() -> Self {
14615 Self {
14616 async_: Default::default(),
14617 config: Default::default(),
14618 create_empty_src_dirs: Default::default(),
14619 dst_fs: Default::default(),
14620 filter: Default::default(),
14621 group: Default::default(),
14622 src_fs: Default::default(),
14623 }
14624 }
14625 }
14626
14627 ///`SyncSyncResponse`
14628 ///
14629 /// <details><summary>JSON schema</summary>
14630 ///
14631 /// ```json
14632 ///{
14633 /// "type": "object",
14634 /// "properties": {
14635 /// "jobid": {
14636 /// "description": "Job ID of the operation.",
14637 /// "type": "integer"
14638 /// }
14639 /// }
14640 ///}
14641 /// ```
14642 /// </details>
14643 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14644 pub struct SyncSyncResponse {
14645 ///Job ID of the operation.
14646 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14647 pub jobid: ::std::option::Option<i64>,
14648 }
14649
14650 impl ::std::convert::From<&SyncSyncResponse> for SyncSyncResponse {
14651 fn from(value: &SyncSyncResponse) -> Self {
14652 value.clone()
14653 }
14654 }
14655
14656 impl ::std::default::Default for SyncSyncResponse {
14657 fn default() -> Self {
14658 Self {
14659 jobid: Default::default(),
14660 }
14661 }
14662 }
14663
14664 ///`VfsForgetRequest`
14665 ///
14666 /// <details><summary>JSON schema</summary>
14667 ///
14668 /// ```json
14669 ///{
14670 /// "type": "object",
14671 /// "properties": {
14672 /// "_async": {
14673 /// "description": "Run the command asynchronously. Returns a job id
14674 /// immediately.",
14675 /// "type": "boolean"
14676 /// },
14677 /// "_group": {
14678 /// "description": "Assign the request to a custom stats group.",
14679 /// "type": "string"
14680 /// },
14681 /// "fs": {
14682 /// "description": "Optional VFS identifier to target; required when
14683 /// more than one VFS is active.",
14684 /// "type": "string"
14685 /// }
14686 /// },
14687 /// "additionalProperties": true
14688 ///}
14689 /// ```
14690 /// </details>
14691 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14692 pub struct VfsForgetRequest {
14693 ///Run the command asynchronously. Returns a job id immediately.
14694 #[serde(
14695 rename = "_async",
14696 default,
14697 skip_serializing_if = "::std::option::Option::is_none"
14698 )]
14699 pub async_: ::std::option::Option<bool>,
14700 ///Optional VFS identifier to target; required when more than one VFS
14701 /// is active.
14702 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14703 pub fs: ::std::option::Option<::std::string::String>,
14704 ///Assign the request to a custom stats group.
14705 #[serde(
14706 rename = "_group",
14707 default,
14708 skip_serializing_if = "::std::option::Option::is_none"
14709 )]
14710 pub group: ::std::option::Option<::std::string::String>,
14711 }
14712
14713 impl ::std::convert::From<&VfsForgetRequest> for VfsForgetRequest {
14714 fn from(value: &VfsForgetRequest) -> Self {
14715 value.clone()
14716 }
14717 }
14718
14719 impl ::std::default::Default for VfsForgetRequest {
14720 fn default() -> Self {
14721 Self {
14722 async_: Default::default(),
14723 fs: Default::default(),
14724 group: Default::default(),
14725 }
14726 }
14727 }
14728
14729 ///`VfsForgetResponse`
14730 ///
14731 /// <details><summary>JSON schema</summary>
14732 ///
14733 /// ```json
14734 ///{
14735 /// "type": "object",
14736 /// "required": [
14737 /// "forgotten"
14738 /// ],
14739 /// "properties": {
14740 /// "forgotten": {
14741 /// "description": "Paths that were successfully forgotten.",
14742 /// "type": "array",
14743 /// "items": {
14744 /// "type": "string"
14745 /// }
14746 /// }
14747 /// }
14748 ///}
14749 /// ```
14750 /// </details>
14751 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14752 pub struct VfsForgetResponse {
14753 ///Paths that were successfully forgotten.
14754 pub forgotten: ::std::vec::Vec<::std::string::String>,
14755 }
14756
14757 impl ::std::convert::From<&VfsForgetResponse> for VfsForgetResponse {
14758 fn from(value: &VfsForgetResponse) -> Self {
14759 value.clone()
14760 }
14761 }
14762
14763 ///`VfsListRequest`
14764 ///
14765 /// <details><summary>JSON schema</summary>
14766 ///
14767 /// ```json
14768 ///{
14769 /// "type": "object",
14770 /// "properties": {
14771 /// "_async": {
14772 /// "description": "Run the command asynchronously. Returns a job id
14773 /// immediately.",
14774 /// "type": "boolean"
14775 /// },
14776 /// "_group": {
14777 /// "description": "Assign the request to a custom stats group.",
14778 /// "type": "string"
14779 /// },
14780 /// "fs": {
14781 /// "description": "Optional VFS identifier; omit to list all active
14782 /// VFS instances.",
14783 /// "type": "string"
14784 /// }
14785 /// }
14786 ///}
14787 /// ```
14788 /// </details>
14789 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14790 pub struct VfsListRequest {
14791 ///Run the command asynchronously. Returns a job id immediately.
14792 #[serde(
14793 rename = "_async",
14794 default,
14795 skip_serializing_if = "::std::option::Option::is_none"
14796 )]
14797 pub async_: ::std::option::Option<bool>,
14798 ///Optional VFS identifier; omit to list all active VFS instances.
14799 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14800 pub fs: ::std::option::Option<::std::string::String>,
14801 ///Assign the request to a custom stats group.
14802 #[serde(
14803 rename = "_group",
14804 default,
14805 skip_serializing_if = "::std::option::Option::is_none"
14806 )]
14807 pub group: ::std::option::Option<::std::string::String>,
14808 }
14809
14810 impl ::std::convert::From<&VfsListRequest> for VfsListRequest {
14811 fn from(value: &VfsListRequest) -> Self {
14812 value.clone()
14813 }
14814 }
14815
14816 impl ::std::default::Default for VfsListRequest {
14817 fn default() -> Self {
14818 Self {
14819 async_: Default::default(),
14820 fs: Default::default(),
14821 group: Default::default(),
14822 }
14823 }
14824 }
14825
14826 ///`VfsListResponse`
14827 ///
14828 /// <details><summary>JSON schema</summary>
14829 ///
14830 /// ```json
14831 ///{
14832 /// "type": "object",
14833 /// "required": [
14834 /// "vfses"
14835 /// ],
14836 /// "properties": {
14837 /// "vfses": {
14838 /// "description": "VFS name that can be used with other VFS
14839 /// endpoints.",
14840 /// "type": "array",
14841 /// "items": {
14842 /// "type": "string"
14843 /// }
14844 /// }
14845 /// }
14846 ///}
14847 /// ```
14848 /// </details>
14849 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14850 pub struct VfsListResponse {
14851 ///VFS name that can be used with other VFS endpoints.
14852 pub vfses: ::std::vec::Vec<::std::string::String>,
14853 }
14854
14855 impl ::std::convert::From<&VfsListResponse> for VfsListResponse {
14856 fn from(value: &VfsListResponse) -> Self {
14857 value.clone()
14858 }
14859 }
14860
14861 ///`VfsPollIntervalRequest`
14862 ///
14863 /// <details><summary>JSON schema</summary>
14864 ///
14865 /// ```json
14866 ///{
14867 /// "type": "object",
14868 /// "properties": {
14869 /// "_async": {
14870 /// "description": "Run the command asynchronously. Returns a job id
14871 /// immediately.",
14872 /// "type": "boolean"
14873 /// },
14874 /// "_group": {
14875 /// "description": "Assign the request to a custom stats group.",
14876 /// "type": "string"
14877 /// },
14878 /// "fs": {
14879 /// "description": "Optional VFS identifier whose poll interval should
14880 /// be queried or modified.",
14881 /// "type": "string"
14882 /// },
14883 /// "interval": {
14884 /// "description": "Duration string (e.g. `5m`) to set as the new poll
14885 /// interval.",
14886 /// "type": "string"
14887 /// },
14888 /// "timeout": {
14889 /// "description": "Duration to wait for the poll interval change to
14890 /// take effect; `0` waits indefinitely.",
14891 /// "type": "string"
14892 /// }
14893 /// }
14894 ///}
14895 /// ```
14896 /// </details>
14897 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14898 pub struct VfsPollIntervalRequest {
14899 ///Run the command asynchronously. Returns a job id immediately.
14900 #[serde(
14901 rename = "_async",
14902 default,
14903 skip_serializing_if = "::std::option::Option::is_none"
14904 )]
14905 pub async_: ::std::option::Option<bool>,
14906 ///Optional VFS identifier whose poll interval should be queried or
14907 /// modified.
14908 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14909 pub fs: ::std::option::Option<::std::string::String>,
14910 ///Assign the request to a custom stats group.
14911 #[serde(
14912 rename = "_group",
14913 default,
14914 skip_serializing_if = "::std::option::Option::is_none"
14915 )]
14916 pub group: ::std::option::Option<::std::string::String>,
14917 ///Duration string (e.g. `5m`) to set as the new poll interval.
14918 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14919 pub interval: ::std::option::Option<::std::string::String>,
14920 ///Duration to wait for the poll interval change to take effect; `0`
14921 /// waits indefinitely.
14922 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14923 pub timeout: ::std::option::Option<::std::string::String>,
14924 }
14925
14926 impl ::std::convert::From<&VfsPollIntervalRequest> for VfsPollIntervalRequest {
14927 fn from(value: &VfsPollIntervalRequest) -> Self {
14928 value.clone()
14929 }
14930 }
14931
14932 impl ::std::default::Default for VfsPollIntervalRequest {
14933 fn default() -> Self {
14934 Self {
14935 async_: Default::default(),
14936 fs: Default::default(),
14937 group: Default::default(),
14938 interval: Default::default(),
14939 timeout: Default::default(),
14940 }
14941 }
14942 }
14943
14944 ///`VfsQueueRequest`
14945 ///
14946 /// <details><summary>JSON schema</summary>
14947 ///
14948 /// ```json
14949 ///{
14950 /// "type": "object",
14951 /// "properties": {
14952 /// "_async": {
14953 /// "description": "Run the command asynchronously. Returns a job id
14954 /// immediately.",
14955 /// "type": "boolean"
14956 /// },
14957 /// "_group": {
14958 /// "description": "Assign the request to a custom stats group.",
14959 /// "type": "string"
14960 /// },
14961 /// "fs": {
14962 /// "description": "Optional VFS identifier whose upload queue should
14963 /// be inspected.",
14964 /// "type": "string"
14965 /// }
14966 /// }
14967 ///}
14968 /// ```
14969 /// </details>
14970 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14971 pub struct VfsQueueRequest {
14972 ///Run the command asynchronously. Returns a job id immediately.
14973 #[serde(
14974 rename = "_async",
14975 default,
14976 skip_serializing_if = "::std::option::Option::is_none"
14977 )]
14978 pub async_: ::std::option::Option<bool>,
14979 ///Optional VFS identifier whose upload queue should be inspected.
14980 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14981 pub fs: ::std::option::Option<::std::string::String>,
14982 ///Assign the request to a custom stats group.
14983 #[serde(
14984 rename = "_group",
14985 default,
14986 skip_serializing_if = "::std::option::Option::is_none"
14987 )]
14988 pub group: ::std::option::Option<::std::string::String>,
14989 }
14990
14991 impl ::std::convert::From<&VfsQueueRequest> for VfsQueueRequest {
14992 fn from(value: &VfsQueueRequest) -> Self {
14993 value.clone()
14994 }
14995 }
14996
14997 impl ::std::default::Default for VfsQueueRequest {
14998 fn default() -> Self {
14999 Self {
15000 async_: Default::default(),
15001 fs: Default::default(),
15002 group: Default::default(),
15003 }
15004 }
15005 }
15006
15007 ///`VfsQueueResponse`
15008 ///
15009 /// <details><summary>JSON schema</summary>
15010 ///
15011 /// ```json
15012 ///{
15013 /// "type": "object",
15014 /// "properties": {
15015 /// "queued": {
15016 /// "type": "array",
15017 /// "items": {
15018 /// "description": "Queued item metadata such as name, size, expiry,
15019 /// and upload state.",
15020 /// "type": "object",
15021 /// "additionalProperties": true
15022 /// }
15023 /// }
15024 /// }
15025 ///}
15026 /// ```
15027 /// </details>
15028 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15029 pub struct VfsQueueResponse {
15030 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15031 pub queued: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
15032 }
15033
15034 impl ::std::convert::From<&VfsQueueResponse> for VfsQueueResponse {
15035 fn from(value: &VfsQueueResponse) -> Self {
15036 value.clone()
15037 }
15038 }
15039
15040 impl ::std::default::Default for VfsQueueResponse {
15041 fn default() -> Self {
15042 Self {
15043 queued: Default::default(),
15044 }
15045 }
15046 }
15047
15048 ///`VfsQueueSetExpiryRequest`
15049 ///
15050 /// <details><summary>JSON schema</summary>
15051 ///
15052 /// ```json
15053 ///{
15054 /// "type": "object",
15055 /// "properties": {
15056 /// "_async": {
15057 /// "description": "Run the command asynchronously. Returns a job id
15058 /// immediately.",
15059 /// "type": "boolean"
15060 /// },
15061 /// "_group": {
15062 /// "description": "Assign the request to a custom stats group.",
15063 /// "type": "string"
15064 /// },
15065 /// "expiry": {
15066 /// "description": "New eligibility time in seconds (may be negative
15067 /// for immediate upload).",
15068 /// "type": "number"
15069 /// },
15070 /// "fs": {
15071 /// "description": "Optional VFS identifier for the queued item.",
15072 /// "type": "string"
15073 /// },
15074 /// "id": {
15075 /// "description": "Queue item ID as returned by `vfs/queue`.",
15076 /// "type": "integer"
15077 /// },
15078 /// "relative": {
15079 /// "description": "Set to true to treat `expiry` as relative to the
15080 /// current value.",
15081 /// "type": "boolean"
15082 /// }
15083 /// }
15084 ///}
15085 /// ```
15086 /// </details>
15087 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15088 pub struct VfsQueueSetExpiryRequest {
15089 ///Run the command asynchronously. Returns a job id immediately.
15090 #[serde(
15091 rename = "_async",
15092 default,
15093 skip_serializing_if = "::std::option::Option::is_none"
15094 )]
15095 pub async_: ::std::option::Option<bool>,
15096 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15097 pub expiry: ::std::option::Option<f64>,
15098 ///Optional VFS identifier for the queued item.
15099 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15100 pub fs: ::std::option::Option<::std::string::String>,
15101 ///Assign the request to a custom stats group.
15102 #[serde(
15103 rename = "_group",
15104 default,
15105 skip_serializing_if = "::std::option::Option::is_none"
15106 )]
15107 pub group: ::std::option::Option<::std::string::String>,
15108 ///Queue item ID as returned by `vfs/queue`.
15109 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15110 pub id: ::std::option::Option<i64>,
15111 ///Set to true to treat `expiry` as relative to the current value.
15112 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15113 pub relative: ::std::option::Option<bool>,
15114 }
15115
15116 impl ::std::convert::From<&VfsQueueSetExpiryRequest> for VfsQueueSetExpiryRequest {
15117 fn from(value: &VfsQueueSetExpiryRequest) -> Self {
15118 value.clone()
15119 }
15120 }
15121
15122 impl ::std::default::Default for VfsQueueSetExpiryRequest {
15123 fn default() -> Self {
15124 Self {
15125 async_: Default::default(),
15126 expiry: Default::default(),
15127 fs: Default::default(),
15128 group: Default::default(),
15129 id: Default::default(),
15130 relative: Default::default(),
15131 }
15132 }
15133 }
15134
15135 ///`VfsQueueSetExpiryResponse`
15136 ///
15137 /// <details><summary>JSON schema</summary>
15138 ///
15139 /// ```json
15140 ///{
15141 /// "type": "object",
15142 /// "properties": {
15143 /// "jobid": {
15144 /// "description": "Job ID returned when _async=true.",
15145 /// "type": "integer"
15146 /// }
15147 /// },
15148 /// "additionalProperties": true
15149 ///}
15150 /// ```
15151 /// </details>
15152 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15153 pub struct VfsQueueSetExpiryResponse {
15154 ///Job ID returned when _async=true.
15155 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15156 pub jobid: ::std::option::Option<i64>,
15157 }
15158
15159 impl ::std::convert::From<&VfsQueueSetExpiryResponse> for VfsQueueSetExpiryResponse {
15160 fn from(value: &VfsQueueSetExpiryResponse) -> Self {
15161 value.clone()
15162 }
15163 }
15164
15165 impl ::std::default::Default for VfsQueueSetExpiryResponse {
15166 fn default() -> Self {
15167 Self {
15168 jobid: Default::default(),
15169 }
15170 }
15171 }
15172
15173 ///`VfsRefreshRequest`
15174 ///
15175 /// <details><summary>JSON schema</summary>
15176 ///
15177 /// ```json
15178 ///{
15179 /// "type": "object",
15180 /// "properties": {
15181 /// "_async": {
15182 /// "description": "Run the command asynchronously. Returns a job id
15183 /// immediately.",
15184 /// "type": "boolean"
15185 /// },
15186 /// "_group": {
15187 /// "description": "Assign the request to a custom stats group.",
15188 /// "type": "string"
15189 /// },
15190 /// "fs": {
15191 /// "description": "Optional VFS identifier whose directory cache
15192 /// should be refreshed.",
15193 /// "type": "string"
15194 /// },
15195 /// "recursive": {
15196 /// "description": "Set to true to refresh entire directory trees.",
15197 /// "type": "boolean"
15198 /// }
15199 /// },
15200 /// "additionalProperties": true
15201 ///}
15202 /// ```
15203 /// </details>
15204 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15205 pub struct VfsRefreshRequest {
15206 ///Run the command asynchronously. Returns a job id immediately.
15207 #[serde(
15208 rename = "_async",
15209 default,
15210 skip_serializing_if = "::std::option::Option::is_none"
15211 )]
15212 pub async_: ::std::option::Option<bool>,
15213 ///Optional VFS identifier whose directory cache should be refreshed.
15214 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15215 pub fs: ::std::option::Option<::std::string::String>,
15216 ///Assign the request to a custom stats group.
15217 #[serde(
15218 rename = "_group",
15219 default,
15220 skip_serializing_if = "::std::option::Option::is_none"
15221 )]
15222 pub group: ::std::option::Option<::std::string::String>,
15223 ///Set to true to refresh entire directory trees.
15224 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15225 pub recursive: ::std::option::Option<bool>,
15226 }
15227
15228 impl ::std::convert::From<&VfsRefreshRequest> for VfsRefreshRequest {
15229 fn from(value: &VfsRefreshRequest) -> Self {
15230 value.clone()
15231 }
15232 }
15233
15234 impl ::std::default::Default for VfsRefreshRequest {
15235 fn default() -> Self {
15236 Self {
15237 async_: Default::default(),
15238 fs: Default::default(),
15239 group: Default::default(),
15240 recursive: Default::default(),
15241 }
15242 }
15243 }
15244
15245 ///`VfsRefreshResponse`
15246 ///
15247 /// <details><summary>JSON schema</summary>
15248 ///
15249 /// ```json
15250 ///{
15251 /// "type": "object",
15252 /// "required": [
15253 /// "result"
15254 /// ],
15255 /// "properties": {
15256 /// "result": {
15257 /// "description": "Map of refreshed directories to status messages.",
15258 /// "type": "object",
15259 /// "additionalProperties": {
15260 /// "type": "string"
15261 /// }
15262 /// }
15263 /// }
15264 ///}
15265 /// ```
15266 /// </details>
15267 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15268 pub struct VfsRefreshResponse {
15269 ///Map of refreshed directories to status messages.
15270 pub result: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
15271 }
15272
15273 impl ::std::convert::From<&VfsRefreshResponse> for VfsRefreshResponse {
15274 fn from(value: &VfsRefreshResponse) -> Self {
15275 value.clone()
15276 }
15277 }
15278
15279 ///`VfsStatsRequest`
15280 ///
15281 /// <details><summary>JSON schema</summary>
15282 ///
15283 /// ```json
15284 ///{
15285 /// "type": "object",
15286 /// "properties": {
15287 /// "_async": {
15288 /// "description": "Run the command asynchronously. Returns a job id
15289 /// immediately.",
15290 /// "type": "boolean"
15291 /// },
15292 /// "_group": {
15293 /// "description": "Assign the request to a custom stats group.",
15294 /// "type": "string"
15295 /// },
15296 /// "fs": {
15297 /// "description": "Optional VFS identifier whose statistics should be
15298 /// returned.",
15299 /// "type": "string"
15300 /// }
15301 /// }
15302 ///}
15303 /// ```
15304 /// </details>
15305 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15306 pub struct VfsStatsRequest {
15307 ///Run the command asynchronously. Returns a job id immediately.
15308 #[serde(
15309 rename = "_async",
15310 default,
15311 skip_serializing_if = "::std::option::Option::is_none"
15312 )]
15313 pub async_: ::std::option::Option<bool>,
15314 ///Optional VFS identifier whose statistics should be returned.
15315 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15316 pub fs: ::std::option::Option<::std::string::String>,
15317 ///Assign the request to a custom stats group.
15318 #[serde(
15319 rename = "_group",
15320 default,
15321 skip_serializing_if = "::std::option::Option::is_none"
15322 )]
15323 pub group: ::std::option::Option<::std::string::String>,
15324 }
15325
15326 impl ::std::convert::From<&VfsStatsRequest> for VfsStatsRequest {
15327 fn from(value: &VfsStatsRequest) -> Self {
15328 value.clone()
15329 }
15330 }
15331
15332 impl ::std::default::Default for VfsStatsRequest {
15333 fn default() -> Self {
15334 Self {
15335 async_: Default::default(),
15336 fs: Default::default(),
15337 group: Default::default(),
15338 }
15339 }
15340 }
15341
15342 ///`VfsStatsResponse`
15343 ///
15344 /// <details><summary>JSON schema</summary>
15345 ///
15346 /// ```json
15347 ///{
15348 /// "type": "object",
15349 /// "required": [
15350 /// "fs",
15351 /// "inUse",
15352 /// "metadataCache",
15353 /// "opt"
15354 /// ],
15355 /// "properties": {
15356 /// "diskCache": {
15357 /// "description": "Disk cache metrics when caching is enabled.",
15358 /// "type": [
15359 /// "object",
15360 /// "null"
15361 /// ],
15362 /// "additionalProperties": true
15363 /// },
15364 /// "fs": {
15365 /// "description": "Name of the VFS.",
15366 /// "type": "string"
15367 /// },
15368 /// "inUse": {
15369 /// "description": "Number of active references to the VFS.",
15370 /// "type": "integer"
15371 /// },
15372 /// "metadataCache": {
15373 /// "description": "In-memory metadata cache counters.",
15374 /// "type": "object",
15375 /// "additionalProperties": {
15376 /// "type": "integer"
15377 /// }
15378 /// },
15379 /// "opt": {
15380 /// "description": "Effective options applied to the VFS.",
15381 /// "type": "object",
15382 /// "additionalProperties": true
15383 /// }
15384 /// }
15385 ///}
15386 /// ```
15387 /// </details>
15388 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15389 pub struct VfsStatsResponse {
15390 ///Disk cache metrics when caching is enabled.
15391 #[serde(
15392 rename = "diskCache",
15393 default,
15394 skip_serializing_if = "::std::option::Option::is_none"
15395 )]
15396 pub disk_cache:
15397 ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
15398 ///Name of the VFS.
15399 pub fs: ::std::string::String,
15400 ///Number of active references to the VFS.
15401 #[serde(rename = "inUse")]
15402 pub in_use: i64,
15403 ///In-memory metadata cache counters.
15404 #[serde(rename = "metadataCache")]
15405 pub metadata_cache: ::std::collections::HashMap<::std::string::String, i64>,
15406 ///Effective options applied to the VFS.
15407 pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
15408 }
15409
15410 impl ::std::convert::From<&VfsStatsResponse> for VfsStatsResponse {
15411 fn from(value: &VfsStatsResponse) -> Self {
15412 value.clone()
15413 }
15414 }
15415}
15416
15417#[derive(Clone, Debug)]
15418///Client for Rclone RC API
15419///
15420///Full OpenAPI specification for the Rclone RC API.
15421///
15422///Version: 1.73.4
15423pub struct Client {
15424 pub(crate) baseurl: String,
15425 pub(crate) client: reqwest::Client,
15426}
15427
15428impl Client {
15429 /// Create a new client.
15430 ///
15431 /// `baseurl` is the base URL provided to the internal
15432 /// `reqwest::Client`, and should include a scheme and hostname,
15433 /// as well as port and a path stem if applicable.
15434 pub fn new(baseurl: &str) -> Self {
15435 #[cfg(not(target_arch = "wasm32"))]
15436 let client = {
15437 let dur = ::std::time::Duration::from_secs(15u64);
15438 reqwest::ClientBuilder::new()
15439 .connect_timeout(dur)
15440 .timeout(dur)
15441 };
15442 #[cfg(target_arch = "wasm32")]
15443 let client = reqwest::ClientBuilder::new();
15444 Self::new_with_client(baseurl, client.build().unwrap())
15445 }
15446
15447 /// Construct a new client with an existing `reqwest::Client`,
15448 /// allowing more control over its configuration.
15449 ///
15450 /// `baseurl` is the base URL provided to the internal
15451 /// `reqwest::Client`, and should include a scheme and hostname,
15452 /// as well as port and a path stem if applicable.
15453 pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
15454 Self {
15455 baseurl: baseurl.to_string(),
15456 client,
15457 }
15458 }
15459}
15460
15461impl ClientInfo<()> for Client {
15462 fn api_version() -> &'static str {
15463 "1.73.4"
15464 }
15465
15466 fn baseurl(&self) -> &str {
15467 self.baseurl.as_str()
15468 }
15469
15470 fn client(&self) -> &reqwest::Client {
15471 &self.client
15472 }
15473
15474 fn inner(&self) -> &() {
15475 &()
15476 }
15477}
15478
15479impl ClientHooks<()> for &Client {}
15480#[allow(clippy::all)]
15481impl Client {
15482 ///Echo request parameters
15483 ///
15484 ///Returns all supplied parameters unchanged so you can verify RC
15485 /// connectivity.
15486 ///
15487 ///Sends a `POST` request to `/rc/noop`
15488 ///
15489 ///Arguments:
15490 /// - `async_`: Run the command asynchronously. Returns a job id
15491 /// immediately.
15492 /// - `params`: Additional arbitrary parameters allowed.
15493 /// - `body`
15494 pub async fn rc_noop<'a>(
15495 &'a self,
15496 async_: Option<bool>,
15497 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
15498 body: &'a types::RcNoopRequest,
15499 ) -> Result<
15500 ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
15501 Error<types::RcError>,
15502 > {
15503 let url = format!("{}/rc/noop", self.baseurl,);
15504 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15505 header_map.append(
15506 ::reqwest::header::HeaderName::from_static("api-version"),
15507 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15508 );
15509 #[allow(unused_mut)]
15510 let mut request = self
15511 .client
15512 .post(url)
15513 .header(
15514 ::reqwest::header::ACCEPT,
15515 ::reqwest::header::HeaderValue::from_static("application/json"),
15516 )
15517 .json(&body)
15518 .query(&progenitor_client::QueryParam::new("_async", &async_))
15519 .query(&progenitor_client::QueryParam::new("params", ¶ms))
15520 .headers(header_map)
15521 .build()?;
15522 let info = OperationInfo {
15523 operation_id: "rc_noop",
15524 };
15525 self.pre(&mut request, &info).await?;
15526 let result = self.exec(request, &info).await;
15527 self.post(&result, &info).await?;
15528 let response = result?;
15529 match response.status().as_u16() {
15530 200u16 => ResponseValue::from_response(response).await,
15531 400u16..=499u16 => Err(Error::ErrorResponse(
15532 ResponseValue::from_response(response).await?,
15533 )),
15534 500u16..=599u16 => Err(Error::ErrorResponse(
15535 ResponseValue::from_response(response).await?,
15536 )),
15537 _ => Err(Error::UnexpectedResponse(response)),
15538 }
15539 }
15540
15541 ///Remove trashed files
15542 ///
15543 ///Permanently removes trashed objects from the specified remote path.
15544 ///
15545 ///Sends a `POST` request to `/operations/cleanup`
15546 ///
15547 ///Arguments:
15548 /// - `async_`: Run the command asynchronously. Returns a job id
15549 /// immediately.
15550 /// - `group`: Assign the request to a custom stats group.
15551 /// - `fs`: Remote name or path to clean up, for example `drive:`.
15552 /// - `body`
15553 pub async fn operations_cleanup<'a>(
15554 &'a self,
15555 async_: Option<bool>,
15556 group: Option<&'a str>,
15557 fs: Option<&'a str>,
15558 body: &'a types::OperationsCleanupRequest,
15559 ) -> Result<ResponseValue<types::OperationsCleanupResponse>, Error<types::RcError>> {
15560 let url = format!("{}/operations/cleanup", self.baseurl,);
15561 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15562 header_map.append(
15563 ::reqwest::header::HeaderName::from_static("api-version"),
15564 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15565 );
15566 #[allow(unused_mut)]
15567 let mut request = self
15568 .client
15569 .post(url)
15570 .header(
15571 ::reqwest::header::ACCEPT,
15572 ::reqwest::header::HeaderValue::from_static("application/json"),
15573 )
15574 .json(&body)
15575 .query(&progenitor_client::QueryParam::new("_async", &async_))
15576 .query(&progenitor_client::QueryParam::new("_group", &group))
15577 .query(&progenitor_client::QueryParam::new("fs", &fs))
15578 .headers(header_map)
15579 .build()?;
15580 let info = OperationInfo {
15581 operation_id: "operations_cleanup",
15582 };
15583 self.pre(&mut request, &info).await?;
15584 let result = self.exec(request, &info).await;
15585 self.post(&result, &info).await?;
15586 let response = result?;
15587 match response.status().as_u16() {
15588 200u16 => ResponseValue::from_response(response).await,
15589 400u16..=499u16 => Err(Error::ErrorResponse(
15590 ResponseValue::from_response(response).await?,
15591 )),
15592 500u16..=599u16 => Err(Error::ErrorResponse(
15593 ResponseValue::from_response(response).await?,
15594 )),
15595 _ => Err(Error::UnexpectedResponse(response)),
15596 }
15597 }
15598
15599 ///Copy a single file
15600 ///
15601 ///Copies one object from a source remote and path to a destination remote
15602 /// and path.
15603 ///
15604 ///Sends a `POST` request to `/operations/copyfile`
15605 ///
15606 ///Arguments:
15607 /// - `async_`: Run the command asynchronously. Returns a job id
15608 /// immediately.
15609 /// - `group`: Assign the request to a custom stats group.
15610 /// - `dst_fs`: Destination remote name or path, such as `drive2:` or `/`
15611 /// for local filesystem.
15612 /// - `dst_remote`: Target path within `dstFs` where the file should be
15613 /// written.
15614 /// - `src_fs`: Source remote name or path, such as `drive:` or `/` for the
15615 /// local filesystem.
15616 /// - `src_remote`: Path to the source object within `srcFs`, for example
15617 /// `dir/file.txt`.
15618 /// - `body`
15619 pub async fn operations_copyfile<'a>(
15620 &'a self,
15621 async_: Option<bool>,
15622 group: Option<&'a str>,
15623 dst_fs: Option<&'a str>,
15624 dst_remote: Option<&'a str>,
15625 src_fs: Option<&'a str>,
15626 src_remote: Option<&'a str>,
15627 body: &'a types::OperationsCopyfileRequest,
15628 ) -> Result<ResponseValue<types::OperationsCopyfileResponse>, Error<types::RcError>> {
15629 let url = format!("{}/operations/copyfile", self.baseurl,);
15630 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15631 header_map.append(
15632 ::reqwest::header::HeaderName::from_static("api-version"),
15633 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15634 );
15635 #[allow(unused_mut)]
15636 let mut request = self
15637 .client
15638 .post(url)
15639 .header(
15640 ::reqwest::header::ACCEPT,
15641 ::reqwest::header::HeaderValue::from_static("application/json"),
15642 )
15643 .json(&body)
15644 .query(&progenitor_client::QueryParam::new("_async", &async_))
15645 .query(&progenitor_client::QueryParam::new("_group", &group))
15646 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
15647 .query(&progenitor_client::QueryParam::new(
15648 "dstRemote",
15649 &dst_remote,
15650 ))
15651 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
15652 .query(&progenitor_client::QueryParam::new(
15653 "srcRemote",
15654 &src_remote,
15655 ))
15656 .headers(header_map)
15657 .build()?;
15658 let info = OperationInfo {
15659 operation_id: "operations_copyfile",
15660 };
15661 self.pre(&mut request, &info).await?;
15662 let result = self.exec(request, &info).await;
15663 self.post(&result, &info).await?;
15664 let response = result?;
15665 match response.status().as_u16() {
15666 200u16 => ResponseValue::from_response(response).await,
15667 400u16..=499u16 => Err(Error::ErrorResponse(
15668 ResponseValue::from_response(response).await?,
15669 )),
15670 500u16..=599u16 => Err(Error::ErrorResponse(
15671 ResponseValue::from_response(response).await?,
15672 )),
15673 _ => Err(Error::UnexpectedResponse(response)),
15674 }
15675 }
15676
15677 ///Copy from URL
15678 ///
15679 ///Downloads a public URL and stores it at the requested remote path.
15680 ///
15681 ///Sends a `POST` request to `/operations/copyurl`
15682 ///
15683 ///Arguments:
15684 /// - `async_`: Run the command asynchronously. Returns a job id
15685 /// immediately.
15686 /// - `group`: Assign the request to a custom stats group.
15687 /// - `auto_filename`: Set to true to derive the destination filename from
15688 /// the URL.
15689 /// - `fs`: Remote name or path that will receive the downloaded file, e.g.
15690 /// `drive:`.
15691 /// - `remote`: Destination path within `fs` where the fetched object will
15692 /// be stored.
15693 /// - `url`: Source URL to fetch the object from.
15694 /// - `body`
15695 pub async fn operations_copyurl<'a>(
15696 &'a self,
15697 async_: Option<bool>,
15698 group: Option<&'a str>,
15699 auto_filename: Option<bool>,
15700 fs: Option<&'a str>,
15701 remote: Option<&'a str>,
15702 url: Option<&'a str>,
15703 body: &'a types::OperationsCopyurlRequest,
15704 ) -> Result<ResponseValue<types::OperationsCopyurlResponse>, Error<types::RcError>> {
15705 let _url = format!("{}/operations/copyurl", self.baseurl,);
15706 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15707 header_map.append(
15708 ::reqwest::header::HeaderName::from_static("api-version"),
15709 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15710 );
15711 #[allow(unused_mut)]
15712 let mut request = self
15713 .client
15714 .post(_url)
15715 .header(
15716 ::reqwest::header::ACCEPT,
15717 ::reqwest::header::HeaderValue::from_static("application/json"),
15718 )
15719 .json(&body)
15720 .query(&progenitor_client::QueryParam::new("_async", &async_))
15721 .query(&progenitor_client::QueryParam::new("_group", &group))
15722 .query(&progenitor_client::QueryParam::new(
15723 "autoFilename",
15724 &auto_filename,
15725 ))
15726 .query(&progenitor_client::QueryParam::new("fs", &fs))
15727 .query(&progenitor_client::QueryParam::new("remote", &remote))
15728 .query(&progenitor_client::QueryParam::new("url", &url))
15729 .headers(header_map)
15730 .build()?;
15731 let info = OperationInfo {
15732 operation_id: "operations_copyurl",
15733 };
15734 self.pre(&mut request, &info).await?;
15735 let result = self.exec(request, &info).await;
15736 self.post(&result, &info).await?;
15737 let response = result?;
15738 match response.status().as_u16() {
15739 200u16 => ResponseValue::from_response(response).await,
15740 400u16..=499u16 => Err(Error::ErrorResponse(
15741 ResponseValue::from_response(response).await?,
15742 )),
15743 500u16..=599u16 => Err(Error::ErrorResponse(
15744 ResponseValue::from_response(response).await?,
15745 )),
15746 _ => Err(Error::UnexpectedResponse(response)),
15747 }
15748 }
15749
15750 ///Delete objects in path
15751 ///
15752 ///Deletes matching files and directories for the provided remote,
15753 /// honouring filters and config overrides.
15754 ///
15755 ///Sends a `POST` request to `/operations/delete`
15756 ///
15757 ///Arguments:
15758 /// - `async_`: Run the command asynchronously. Returns a job id
15759 /// immediately.
15760 /// - `config`: JSON encoded config overrides applied for this call only.
15761 /// - `filter`: JSON encoded filter overrides applied for this call only.
15762 /// - `group`: Assign the request to a custom stats group.
15763 /// - `fs`: Remote name or path whose contents should be removed.
15764 /// - `body`
15765 pub async fn operations_delete<'a>(
15766 &'a self,
15767 async_: Option<bool>,
15768 config: Option<&'a str>,
15769 filter: Option<&'a str>,
15770 group: Option<&'a str>,
15771 fs: Option<&'a str>,
15772 body: &'a types::OperationsDeleteRequest,
15773 ) -> Result<ResponseValue<types::OperationsDeleteResponse>, Error<types::RcError>> {
15774 let url = format!("{}/operations/delete", self.baseurl,);
15775 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15776 header_map.append(
15777 ::reqwest::header::HeaderName::from_static("api-version"),
15778 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15779 );
15780 #[allow(unused_mut)]
15781 let mut request = self
15782 .client
15783 .post(url)
15784 .header(
15785 ::reqwest::header::ACCEPT,
15786 ::reqwest::header::HeaderValue::from_static("application/json"),
15787 )
15788 .json(&body)
15789 .query(&progenitor_client::QueryParam::new("_async", &async_))
15790 .query(&progenitor_client::QueryParam::new("_config", &config))
15791 .query(&progenitor_client::QueryParam::new("_filter", &filter))
15792 .query(&progenitor_client::QueryParam::new("_group", &group))
15793 .query(&progenitor_client::QueryParam::new("fs", &fs))
15794 .headers(header_map)
15795 .build()?;
15796 let info = OperationInfo {
15797 operation_id: "operations_delete",
15798 };
15799 self.pre(&mut request, &info).await?;
15800 let result = self.exec(request, &info).await;
15801 self.post(&result, &info).await?;
15802 let response = result?;
15803 match response.status().as_u16() {
15804 200u16 => ResponseValue::from_response(response).await,
15805 400u16..=499u16 => Err(Error::ErrorResponse(
15806 ResponseValue::from_response(response).await?,
15807 )),
15808 500u16..=599u16 => Err(Error::ErrorResponse(
15809 ResponseValue::from_response(response).await?,
15810 )),
15811 _ => Err(Error::UnexpectedResponse(response)),
15812 }
15813 }
15814
15815 ///Delete single file
15816 ///
15817 ///Removes a specific object from the remote.
15818 ///
15819 ///Sends a `POST` request to `/operations/deletefile`
15820 ///
15821 ///Arguments:
15822 /// - `async_`: Run the command asynchronously. Returns a job id
15823 /// immediately.
15824 /// - `group`: Assign the request to a custom stats group.
15825 /// - `fs`: Remote name or path that contains the file to delete.
15826 /// - `remote`: Exact path to the file within `fs` that should be deleted.
15827 /// - `body`
15828 pub async fn operations_deletefile<'a>(
15829 &'a self,
15830 async_: Option<bool>,
15831 group: Option<&'a str>,
15832 fs: Option<&'a str>,
15833 remote: Option<&'a str>,
15834 body: &'a types::OperationsDeletefileRequest,
15835 ) -> Result<ResponseValue<types::OperationsDeletefileResponse>, Error<types::RcError>> {
15836 let url = format!("{}/operations/deletefile", self.baseurl,);
15837 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15838 header_map.append(
15839 ::reqwest::header::HeaderName::from_static("api-version"),
15840 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15841 );
15842 #[allow(unused_mut)]
15843 let mut request = self
15844 .client
15845 .post(url)
15846 .header(
15847 ::reqwest::header::ACCEPT,
15848 ::reqwest::header::HeaderValue::from_static("application/json"),
15849 )
15850 .json(&body)
15851 .query(&progenitor_client::QueryParam::new("_async", &async_))
15852 .query(&progenitor_client::QueryParam::new("_group", &group))
15853 .query(&progenitor_client::QueryParam::new("fs", &fs))
15854 .query(&progenitor_client::QueryParam::new("remote", &remote))
15855 .headers(header_map)
15856 .build()?;
15857 let info = OperationInfo {
15858 operation_id: "operations_deletefile",
15859 };
15860 self.pre(&mut request, &info).await?;
15861 let result = self.exec(request, &info).await;
15862 self.post(&result, &info).await?;
15863 let response = result?;
15864 match response.status().as_u16() {
15865 200u16 => ResponseValue::from_response(response).await,
15866 400u16..=499u16 => Err(Error::ErrorResponse(
15867 ResponseValue::from_response(response).await?,
15868 )),
15869 500u16..=599u16 => Err(Error::ErrorResponse(
15870 ResponseValue::from_response(response).await?,
15871 )),
15872 _ => Err(Error::UnexpectedResponse(response)),
15873 }
15874 }
15875
15876 ///Describe remote capabilities
15877 ///
15878 ///Returns backend features, hash support, metadata descriptions, and other
15879 /// info for the remote.
15880 ///
15881 ///Sends a `POST` request to `/operations/fsinfo`
15882 ///
15883 ///Arguments:
15884 /// - `async_`: Run the command asynchronously. Returns a job id
15885 /// immediately.
15886 /// - `group`: Assign the request to a custom stats group.
15887 /// - `fs`: Remote name or path to inspect, e.g. `drive:`.
15888 /// - `body`
15889 pub async fn operations_fsinfo<'a>(
15890 &'a self,
15891 async_: Option<bool>,
15892 group: Option<&'a str>,
15893 fs: Option<&'a str>,
15894 body: &'a types::OperationsFsinfoRequest,
15895 ) -> Result<ResponseValue<types::OperationsFsinfoResponse>, Error<types::RcError>> {
15896 let url = format!("{}/operations/fsinfo", self.baseurl,);
15897 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15898 header_map.append(
15899 ::reqwest::header::HeaderName::from_static("api-version"),
15900 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15901 );
15902 #[allow(unused_mut)]
15903 let mut request = self
15904 .client
15905 .post(url)
15906 .header(
15907 ::reqwest::header::ACCEPT,
15908 ::reqwest::header::HeaderValue::from_static("application/json"),
15909 )
15910 .json(&body)
15911 .query(&progenitor_client::QueryParam::new("_async", &async_))
15912 .query(&progenitor_client::QueryParam::new("_group", &group))
15913 .query(&progenitor_client::QueryParam::new("fs", &fs))
15914 .headers(header_map)
15915 .build()?;
15916 let info = OperationInfo {
15917 operation_id: "operations_fsinfo",
15918 };
15919 self.pre(&mut request, &info).await?;
15920 let result = self.exec(request, &info).await;
15921 self.post(&result, &info).await?;
15922 let response = result?;
15923 match response.status().as_u16() {
15924 200u16 => ResponseValue::from_response(response).await,
15925 400u16..=499u16 => Err(Error::ErrorResponse(
15926 ResponseValue::from_response(response).await?,
15927 )),
15928 500u16..=599u16 => Err(Error::ErrorResponse(
15929 ResponseValue::from_response(response).await?,
15930 )),
15931 _ => Err(Error::UnexpectedResponse(response)),
15932 }
15933 }
15934
15935 ///Generate hash sums
15936 ///
15937 ///Produces a hash sum listing for files under the given path using the
15938 /// requested hash algorithm.
15939 ///
15940 ///Sends a `POST` request to `/operations/hashsum`
15941 ///
15942 ///Arguments:
15943 /// - `async_`: Run the command asynchronously. Returns a job id
15944 /// immediately.
15945 /// - `group`: Assign the request to a custom stats group.
15946 /// - `base64`: Set to true to emit hash values in base64 rather than
15947 /// hexadecimal.
15948 /// - `download`: Set to true to force reading the data instead of using
15949 /// remote checksums.
15950 /// - `fs`: Remote name or path to hash, such as `drive:` or `/`.
15951 /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
15952 /// supported name.
15953 /// - `body`
15954 pub async fn operations_hashsum<'a>(
15955 &'a self,
15956 async_: Option<bool>,
15957 group: Option<&'a str>,
15958 base64: Option<bool>,
15959 download: Option<bool>,
15960 fs: Option<&'a str>,
15961 hash_type: Option<&'a str>,
15962 body: &'a types::OperationsHashsumRequest,
15963 ) -> Result<ResponseValue<types::OperationsHashsumResponse>, Error<types::RcError>> {
15964 let url = format!("{}/operations/hashsum", self.baseurl,);
15965 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
15966 header_map.append(
15967 ::reqwest::header::HeaderName::from_static("api-version"),
15968 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
15969 );
15970 #[allow(unused_mut)]
15971 let mut request = self
15972 .client
15973 .post(url)
15974 .header(
15975 ::reqwest::header::ACCEPT,
15976 ::reqwest::header::HeaderValue::from_static("application/json"),
15977 )
15978 .json(&body)
15979 .query(&progenitor_client::QueryParam::new("_async", &async_))
15980 .query(&progenitor_client::QueryParam::new("_group", &group))
15981 .query(&progenitor_client::QueryParam::new("base64", &base64))
15982 .query(&progenitor_client::QueryParam::new("download", &download))
15983 .query(&progenitor_client::QueryParam::new("fs", &fs))
15984 .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
15985 .headers(header_map)
15986 .build()?;
15987 let info = OperationInfo {
15988 operation_id: "operations_hashsum",
15989 };
15990 self.pre(&mut request, &info).await?;
15991 let result = self.exec(request, &info).await;
15992 self.post(&result, &info).await?;
15993 let response = result?;
15994 match response.status().as_u16() {
15995 200u16 => ResponseValue::from_response(response).await,
15996 400u16..=499u16 => Err(Error::ErrorResponse(
15997 ResponseValue::from_response(response).await?,
15998 )),
15999 500u16..=599u16 => Err(Error::ErrorResponse(
16000 ResponseValue::from_response(response).await?,
16001 )),
16002 _ => Err(Error::UnexpectedResponse(response)),
16003 }
16004 }
16005
16006 ///Hash a single file
16007 ///
16008 ///Returns the hash of a single file using the specified hash algorithm.
16009 ///
16010 ///Sends a `POST` request to `/operations/hashsumfile`
16011 ///
16012 ///Arguments:
16013 /// - `async_`: Run the command asynchronously. Returns a job id
16014 /// immediately.
16015 /// - `group`: Assign the request to a custom stats group.
16016 /// - `base64`: Set to true to emit the hash value in base64 rather than
16017 /// hexadecimal.
16018 /// - `download`: Set to true to force reading the data instead of using
16019 /// remote checksums.
16020 /// - `fs`: Remote name or path containing the file to hash.
16021 /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
16022 /// supported name.
16023 /// - `remote`: Path to the specific file within `fs` to hash.
16024 /// - `body`
16025 pub async fn operations_hashsumfile<'a>(
16026 &'a self,
16027 async_: Option<bool>,
16028 group: Option<&'a str>,
16029 base64: Option<bool>,
16030 download: Option<bool>,
16031 fs: Option<&'a str>,
16032 hash_type: Option<&'a str>,
16033 remote: Option<&'a str>,
16034 body: &'a types::OperationsHashsumfileRequest,
16035 ) -> Result<ResponseValue<types::OperationsHashsumfileResponse>, Error<types::RcError>> {
16036 let url = format!("{}/operations/hashsumfile", self.baseurl,);
16037 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16038 header_map.append(
16039 ::reqwest::header::HeaderName::from_static("api-version"),
16040 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16041 );
16042 #[allow(unused_mut)]
16043 let mut request = self
16044 .client
16045 .post(url)
16046 .header(
16047 ::reqwest::header::ACCEPT,
16048 ::reqwest::header::HeaderValue::from_static("application/json"),
16049 )
16050 .json(&body)
16051 .query(&progenitor_client::QueryParam::new("_async", &async_))
16052 .query(&progenitor_client::QueryParam::new("_group", &group))
16053 .query(&progenitor_client::QueryParam::new("base64", &base64))
16054 .query(&progenitor_client::QueryParam::new("download", &download))
16055 .query(&progenitor_client::QueryParam::new("fs", &fs))
16056 .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
16057 .query(&progenitor_client::QueryParam::new("remote", &remote))
16058 .headers(header_map)
16059 .build()?;
16060 let info = OperationInfo {
16061 operation_id: "operations_hashsumfile",
16062 };
16063 self.pre(&mut request, &info).await?;
16064 let result = self.exec(request, &info).await;
16065 self.post(&result, &info).await?;
16066 let response = result?;
16067 match response.status().as_u16() {
16068 200u16 => ResponseValue::from_response(response).await,
16069 400u16..=499u16 => Err(Error::ErrorResponse(
16070 ResponseValue::from_response(response).await?,
16071 )),
16072 500u16..=599u16 => Err(Error::ErrorResponse(
16073 ResponseValue::from_response(response).await?,
16074 )),
16075 _ => Err(Error::UnexpectedResponse(response)),
16076 }
16077 }
16078
16079 ///Move a single file
16080 ///
16081 ///Moves one object from a source remote and path to a destination remote
16082 /// and path.
16083 ///
16084 ///Sends a `POST` request to `/operations/movefile`
16085 ///
16086 ///Arguments:
16087 /// - `async_`: Run the command asynchronously. Returns a job id
16088 /// immediately.
16089 /// - `group`: Assign the request to a custom stats group.
16090 /// - `dst_fs`: Destination remote name or path where the file will be
16091 /// moved.
16092 /// - `dst_remote`: Destination path within `dstFs` for the moved object.
16093 /// - `src_fs`: Source remote name or path containing the file to move.
16094 /// - `src_remote`: Path to the source object within `srcFs`.
16095 /// - `body`
16096 pub async fn operations_movefile<'a>(
16097 &'a self,
16098 async_: Option<bool>,
16099 group: Option<&'a str>,
16100 dst_fs: Option<&'a str>,
16101 dst_remote: Option<&'a str>,
16102 src_fs: Option<&'a str>,
16103 src_remote: Option<&'a str>,
16104 body: &'a types::OperationsMovefileRequest,
16105 ) -> Result<ResponseValue<types::OperationsMovefileResponse>, Error<types::RcError>> {
16106 let url = format!("{}/operations/movefile", self.baseurl,);
16107 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16108 header_map.append(
16109 ::reqwest::header::HeaderName::from_static("api-version"),
16110 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16111 );
16112 #[allow(unused_mut)]
16113 let mut request = self
16114 .client
16115 .post(url)
16116 .header(
16117 ::reqwest::header::ACCEPT,
16118 ::reqwest::header::HeaderValue::from_static("application/json"),
16119 )
16120 .json(&body)
16121 .query(&progenitor_client::QueryParam::new("_async", &async_))
16122 .query(&progenitor_client::QueryParam::new("_group", &group))
16123 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
16124 .query(&progenitor_client::QueryParam::new(
16125 "dstRemote",
16126 &dst_remote,
16127 ))
16128 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
16129 .query(&progenitor_client::QueryParam::new(
16130 "srcRemote",
16131 &src_remote,
16132 ))
16133 .headers(header_map)
16134 .build()?;
16135 let info = OperationInfo {
16136 operation_id: "operations_movefile",
16137 };
16138 self.pre(&mut request, &info).await?;
16139 let result = self.exec(request, &info).await;
16140 self.post(&result, &info).await?;
16141 let response = result?;
16142 match response.status().as_u16() {
16143 200u16 => ResponseValue::from_response(response).await,
16144 400u16..=499u16 => Err(Error::ErrorResponse(
16145 ResponseValue::from_response(response).await?,
16146 )),
16147 500u16..=599u16 => Err(Error::ErrorResponse(
16148 ResponseValue::from_response(response).await?,
16149 )),
16150 _ => Err(Error::UnexpectedResponse(response)),
16151 }
16152 }
16153
16154 ///Create or remove public link
16155 ///
16156 ///Creates a share URL for an object or removes an existing link when
16157 /// `unlink=true`.
16158 ///
16159 ///Sends a `POST` request to `/operations/publiclink`
16160 ///
16161 ///Arguments:
16162 /// - `async_`: Run the command asynchronously. Returns a job id
16163 /// immediately.
16164 /// - `group`: Assign the request to a custom stats group.
16165 /// - `expire`: Optional expiration time for the public link, formatted as
16166 /// supported by the backend.
16167 /// - `fs`: Remote name or path hosting the object for which to manage a
16168 /// public link.
16169 /// - `remote`: Path within `fs` to the object for which to create or remove
16170 /// a public link.
16171 /// - `unlink`: Set to true to remove an existing public link instead of
16172 /// creating one.
16173 /// - `body`
16174 pub async fn operations_publiclink<'a>(
16175 &'a self,
16176 async_: Option<bool>,
16177 group: Option<&'a str>,
16178 expire: Option<&'a str>,
16179 fs: Option<&'a str>,
16180 remote: Option<&'a str>,
16181 unlink: Option<bool>,
16182 body: &'a types::OperationsPubliclinkRequest,
16183 ) -> Result<ResponseValue<types::OperationsPubliclinkResponse>, Error<types::RcError>> {
16184 let url = format!("{}/operations/publiclink", self.baseurl,);
16185 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16186 header_map.append(
16187 ::reqwest::header::HeaderName::from_static("api-version"),
16188 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16189 );
16190 #[allow(unused_mut)]
16191 let mut request = self
16192 .client
16193 .post(url)
16194 .header(
16195 ::reqwest::header::ACCEPT,
16196 ::reqwest::header::HeaderValue::from_static("application/json"),
16197 )
16198 .json(&body)
16199 .query(&progenitor_client::QueryParam::new("_async", &async_))
16200 .query(&progenitor_client::QueryParam::new("_group", &group))
16201 .query(&progenitor_client::QueryParam::new("expire", &expire))
16202 .query(&progenitor_client::QueryParam::new("fs", &fs))
16203 .query(&progenitor_client::QueryParam::new("remote", &remote))
16204 .query(&progenitor_client::QueryParam::new("unlink", &unlink))
16205 .headers(header_map)
16206 .build()?;
16207 let info = OperationInfo {
16208 operation_id: "operations_publiclink",
16209 };
16210 self.pre(&mut request, &info).await?;
16211 let result = self.exec(request, &info).await;
16212 self.post(&result, &info).await?;
16213 let response = result?;
16214 match response.status().as_u16() {
16215 200u16 => ResponseValue::from_response(response).await,
16216 400u16..=499u16 => Err(Error::ErrorResponse(
16217 ResponseValue::from_response(response).await?,
16218 )),
16219 500u16..=599u16 => Err(Error::ErrorResponse(
16220 ResponseValue::from_response(response).await?,
16221 )),
16222 _ => Err(Error::UnexpectedResponse(response)),
16223 }
16224 }
16225
16226 ///Remove empty directories
16227 ///
16228 ///Deletes empty subdirectories beneath the specified path, optionally
16229 /// leaving the root.
16230 ///
16231 ///Sends a `POST` request to `/operations/rmdirs`
16232 ///
16233 ///Arguments:
16234 /// - `async_`: Run the command asynchronously. Returns a job id
16235 /// immediately.
16236 /// - `group`: Assign the request to a custom stats group.
16237 /// - `fs`: Remote name or path to scan for empty directories.
16238 /// - `leave_root`: Set to true to preserve the top-level directory even if
16239 /// empty.
16240 /// - `remote`: Path within `fs` whose empty subdirectories should be
16241 /// removed.
16242 /// - `body`
16243 pub async fn operations_rmdirs<'a>(
16244 &'a self,
16245 async_: Option<bool>,
16246 group: Option<&'a str>,
16247 fs: Option<&'a str>,
16248 leave_root: Option<bool>,
16249 remote: Option<&'a str>,
16250 body: &'a types::OperationsRmdirsRequest,
16251 ) -> Result<ResponseValue<types::OperationsRmdirsResponse>, Error<types::RcError>> {
16252 let url = format!("{}/operations/rmdirs", self.baseurl,);
16253 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16254 header_map.append(
16255 ::reqwest::header::HeaderName::from_static("api-version"),
16256 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16257 );
16258 #[allow(unused_mut)]
16259 let mut request = self
16260 .client
16261 .post(url)
16262 .header(
16263 ::reqwest::header::ACCEPT,
16264 ::reqwest::header::HeaderValue::from_static("application/json"),
16265 )
16266 .json(&body)
16267 .query(&progenitor_client::QueryParam::new("_async", &async_))
16268 .query(&progenitor_client::QueryParam::new("_group", &group))
16269 .query(&progenitor_client::QueryParam::new("fs", &fs))
16270 .query(&progenitor_client::QueryParam::new(
16271 "leaveRoot",
16272 &leave_root,
16273 ))
16274 .query(&progenitor_client::QueryParam::new("remote", &remote))
16275 .headers(header_map)
16276 .build()?;
16277 let info = OperationInfo {
16278 operation_id: "operations_rmdirs",
16279 };
16280 self.pre(&mut request, &info).await?;
16281 let result = self.exec(request, &info).await;
16282 self.post(&result, &info).await?;
16283 let response = result?;
16284 match response.status().as_u16() {
16285 200u16 => ResponseValue::from_response(response).await,
16286 400u16..=499u16 => Err(Error::ErrorResponse(
16287 ResponseValue::from_response(response).await?,
16288 )),
16289 500u16..=599u16 => Err(Error::ErrorResponse(
16290 ResponseValue::from_response(response).await?,
16291 )),
16292 _ => Err(Error::UnexpectedResponse(response)),
16293 }
16294 }
16295
16296 ///Change storage tier
16297 ///
16298 ///Updates the storage class or tier for every object in the specified
16299 /// remote path.
16300 ///
16301 ///Sends a `POST` request to `/operations/settier`
16302 ///
16303 ///Arguments:
16304 /// - `async_`: Run the command asynchronously. Returns a job id
16305 /// immediately.
16306 /// - `group`: Assign the request to a custom stats group.
16307 /// - `fs`: Remote name or path whose storage class tier should be changed.
16308 /// - `body`
16309 pub async fn operations_settier<'a>(
16310 &'a self,
16311 async_: Option<bool>,
16312 group: Option<&'a str>,
16313 fs: Option<&'a str>,
16314 body: &'a types::OperationsSettierRequest,
16315 ) -> Result<ResponseValue<types::OperationsSettierResponse>, Error<types::RcError>> {
16316 let url = format!("{}/operations/settier", self.baseurl,);
16317 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16318 header_map.append(
16319 ::reqwest::header::HeaderName::from_static("api-version"),
16320 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16321 );
16322 #[allow(unused_mut)]
16323 let mut request = self
16324 .client
16325 .post(url)
16326 .header(
16327 ::reqwest::header::ACCEPT,
16328 ::reqwest::header::HeaderValue::from_static("application/json"),
16329 )
16330 .json(&body)
16331 .query(&progenitor_client::QueryParam::new("_async", &async_))
16332 .query(&progenitor_client::QueryParam::new("_group", &group))
16333 .query(&progenitor_client::QueryParam::new("fs", &fs))
16334 .headers(header_map)
16335 .build()?;
16336 let info = OperationInfo {
16337 operation_id: "operations_settier",
16338 };
16339 self.pre(&mut request, &info).await?;
16340 let result = self.exec(request, &info).await;
16341 self.post(&result, &info).await?;
16342 let response = result?;
16343 match response.status().as_u16() {
16344 200u16 => ResponseValue::from_response(response).await,
16345 400u16..=499u16 => Err(Error::ErrorResponse(
16346 ResponseValue::from_response(response).await?,
16347 )),
16348 500u16..=599u16 => Err(Error::ErrorResponse(
16349 ResponseValue::from_response(response).await?,
16350 )),
16351 _ => Err(Error::UnexpectedResponse(response)),
16352 }
16353 }
16354
16355 ///Change file storage tier
16356 ///
16357 ///Updates the storage class or tier for a single object.
16358 ///
16359 ///Sends a `POST` request to `/operations/settierfile`
16360 ///
16361 ///Arguments:
16362 /// - `async_`: Run the command asynchronously. Returns a job id
16363 /// immediately.
16364 /// - `group`: Assign the request to a custom stats group.
16365 /// - `fs`: Remote name or path that contains the object whose tier should
16366 /// change.
16367 /// - `remote`: Path within `fs` to the object whose storage class tier
16368 /// should be updated.
16369 /// - `body`
16370 pub async fn operations_settierfile<'a>(
16371 &'a self,
16372 async_: Option<bool>,
16373 group: Option<&'a str>,
16374 fs: Option<&'a str>,
16375 remote: Option<&'a str>,
16376 body: &'a types::OperationsSettierfileRequest,
16377 ) -> Result<ResponseValue<types::OperationsSettierfileResponse>, Error<types::RcError>> {
16378 let url = format!("{}/operations/settierfile", self.baseurl,);
16379 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16380 header_map.append(
16381 ::reqwest::header::HeaderName::from_static("api-version"),
16382 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16383 );
16384 #[allow(unused_mut)]
16385 let mut request = self
16386 .client
16387 .post(url)
16388 .header(
16389 ::reqwest::header::ACCEPT,
16390 ::reqwest::header::HeaderValue::from_static("application/json"),
16391 )
16392 .json(&body)
16393 .query(&progenitor_client::QueryParam::new("_async", &async_))
16394 .query(&progenitor_client::QueryParam::new("_group", &group))
16395 .query(&progenitor_client::QueryParam::new("fs", &fs))
16396 .query(&progenitor_client::QueryParam::new("remote", &remote))
16397 .headers(header_map)
16398 .build()?;
16399 let info = OperationInfo {
16400 operation_id: "operations_settierfile",
16401 };
16402 self.pre(&mut request, &info).await?;
16403 let result = self.exec(request, &info).await;
16404 self.post(&result, &info).await?;
16405 let response = result?;
16406 match response.status().as_u16() {
16407 200u16 => ResponseValue::from_response(response).await,
16408 400u16..=499u16 => Err(Error::ErrorResponse(
16409 ResponseValue::from_response(response).await?,
16410 )),
16411 500u16..=599u16 => Err(Error::ErrorResponse(
16412 ResponseValue::from_response(response).await?,
16413 )),
16414 _ => Err(Error::UnexpectedResponse(response)),
16415 }
16416 }
16417
16418 ///Count remote size
16419 ///
16420 ///Reports total size, file count, and number of objects without size
16421 /// metadata.
16422 ///
16423 ///Sends a `POST` request to `/operations/size`
16424 ///
16425 ///Arguments:
16426 /// - `async_`: Run the command asynchronously. Returns a job id
16427 /// immediately.
16428 /// - `group`: Assign the request to a custom stats group.
16429 /// - `fs`: Remote name or path to measure aggregate size information for.
16430 /// - `body`
16431 pub async fn operations_size<'a>(
16432 &'a self,
16433 async_: Option<bool>,
16434 group: Option<&'a str>,
16435 fs: Option<&'a str>,
16436 body: &'a types::OperationsSizeRequest,
16437 ) -> Result<ResponseValue<types::OperationsSizeResponse>, Error<types::RcError>> {
16438 let url = format!("{}/operations/size", self.baseurl,);
16439 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16440 header_map.append(
16441 ::reqwest::header::HeaderName::from_static("api-version"),
16442 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16443 );
16444 #[allow(unused_mut)]
16445 let mut request = self
16446 .client
16447 .post(url)
16448 .header(
16449 ::reqwest::header::ACCEPT,
16450 ::reqwest::header::HeaderValue::from_static("application/json"),
16451 )
16452 .json(&body)
16453 .query(&progenitor_client::QueryParam::new("_async", &async_))
16454 .query(&progenitor_client::QueryParam::new("_group", &group))
16455 .query(&progenitor_client::QueryParam::new("fs", &fs))
16456 .headers(header_map)
16457 .build()?;
16458 let info = OperationInfo {
16459 operation_id: "operations_size",
16460 };
16461 self.pre(&mut request, &info).await?;
16462 let result = self.exec(request, &info).await;
16463 self.post(&result, &info).await?;
16464 let response = result?;
16465 match response.status().as_u16() {
16466 200u16 => ResponseValue::from_response(response).await,
16467 400u16..=499u16 => Err(Error::ErrorResponse(
16468 ResponseValue::from_response(response).await?,
16469 )),
16470 500u16..=599u16 => Err(Error::ErrorResponse(
16471 ResponseValue::from_response(response).await?,
16472 )),
16473 _ => Err(Error::UnexpectedResponse(response)),
16474 }
16475 }
16476
16477 ///Get or update bandwidth limits
16478 ///
16479 ///Reads the current bandwidth limit or applies a new schedule string, just
16480 /// like `rclone rc core/bwlimit`.
16481 ///
16482 ///Sends a `POST` request to `/core/bwlimit`
16483 ///
16484 ///Arguments:
16485 /// - `async_`: Run the command asynchronously. Returns a job id
16486 /// immediately.
16487 /// - `group`: Assign the request to a custom stats group.
16488 /// - `rate`: Bandwidth limit to apply, for example `off`, `5M`, or a
16489 /// schedule string.
16490 /// - `body`
16491 pub async fn core_bwlimit<'a>(
16492 &'a self,
16493 async_: Option<bool>,
16494 group: Option<&'a str>,
16495 rate: Option<&'a str>,
16496 body: &'a types::CoreBwlimitRequest,
16497 ) -> Result<ResponseValue<types::CoreBwlimitResponse>, Error<types::RcError>> {
16498 let url = format!("{}/core/bwlimit", self.baseurl,);
16499 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16500 header_map.append(
16501 ::reqwest::header::HeaderName::from_static("api-version"),
16502 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16503 );
16504 #[allow(unused_mut)]
16505 let mut request = self
16506 .client
16507 .post(url)
16508 .header(
16509 ::reqwest::header::ACCEPT,
16510 ::reqwest::header::HeaderValue::from_static("application/json"),
16511 )
16512 .json(&body)
16513 .query(&progenitor_client::QueryParam::new("_async", &async_))
16514 .query(&progenitor_client::QueryParam::new("_group", &group))
16515 .query(&progenitor_client::QueryParam::new("rate", &rate))
16516 .headers(header_map)
16517 .build()?;
16518 let info = OperationInfo {
16519 operation_id: "core_bwlimit",
16520 };
16521 self.pre(&mut request, &info).await?;
16522 let result = self.exec(request, &info).await;
16523 self.post(&result, &info).await?;
16524 let response = result?;
16525 match response.status().as_u16() {
16526 200u16 => ResponseValue::from_response(response).await,
16527 400u16..=499u16 => Err(Error::ErrorResponse(
16528 ResponseValue::from_response(response).await?,
16529 )),
16530 500u16..=599u16 => Err(Error::ErrorResponse(
16531 ResponseValue::from_response(response).await?,
16532 )),
16533 _ => Err(Error::UnexpectedResponse(response)),
16534 }
16535 }
16536
16537 ///Run an rclone command
16538 ///
16539 ///Executes a standard rclone CLI command remotely and streams or returns
16540 /// its output.
16541 ///
16542 ///Sends a `POST` request to `/core/command`
16543 ///
16544 ///Arguments:
16545 /// - `async_`: Run the command asynchronously. Returns a job id
16546 /// immediately.
16547 /// - `group`: Assign the request to a custom stats group.
16548 /// - `arg`: Optional positional arguments for the command. Repeat to supply
16549 /// multiple values.
16550 /// - `command`: Name of the rclone command to execute, for example `ls` or
16551 /// `lsf`.
16552 /// - `opt`: Optional command options encoded as a JSON string.
16553 /// - `return_type`: Controls how output is returned; accepts
16554 /// `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
16555 /// `STREAM_ONLY_STDERR`.
16556 /// - `body`
16557 pub async fn core_command<'a>(
16558 &'a self,
16559 async_: Option<bool>,
16560 group: Option<&'a str>,
16561 arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
16562 command: Option<&'a str>,
16563 opt: Option<&'a str>,
16564 return_type: Option<&'a str>,
16565 body: &'a types::CoreCommandRequest,
16566 ) -> Result<ResponseValue<types::CoreCommandResponse>, Error<types::RcError>> {
16567 let url = format!("{}/core/command", self.baseurl,);
16568 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16569 header_map.append(
16570 ::reqwest::header::HeaderName::from_static("api-version"),
16571 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16572 );
16573 #[allow(unused_mut)]
16574 let mut request = self
16575 .client
16576 .post(url)
16577 .header(
16578 ::reqwest::header::ACCEPT,
16579 ::reqwest::header::HeaderValue::from_static("application/json"),
16580 )
16581 .json(&body)
16582 .query(&progenitor_client::QueryParam::new("_async", &async_))
16583 .query(&progenitor_client::QueryParam::new("_group", &group))
16584 .query(&progenitor_client::QueryParam::new("arg", &arg))
16585 .query(&progenitor_client::QueryParam::new("command", &command))
16586 .query(&progenitor_client::QueryParam::new("opt", &opt))
16587 .query(&progenitor_client::QueryParam::new(
16588 "returnType",
16589 &return_type,
16590 ))
16591 .headers(header_map)
16592 .build()?;
16593 let info = OperationInfo {
16594 operation_id: "core_command",
16595 };
16596 self.pre(&mut request, &info).await?;
16597 let result = self.exec(request, &info).await;
16598 self.post(&result, &info).await?;
16599 let response = result?;
16600 match response.status().as_u16() {
16601 200u16 => ResponseValue::from_response(response).await,
16602 400u16..=499u16 => Err(Error::ErrorResponse(
16603 ResponseValue::from_response(response).await?,
16604 )),
16605 500u16..=599u16 => Err(Error::ErrorResponse(
16606 ResponseValue::from_response(response).await?,
16607 )),
16608 _ => Err(Error::UnexpectedResponse(response)),
16609 }
16610 }
16611
16612 ///List locally accessible paths
16613 ///
16614 ///Returns a list of locally accessible paths including mount points, user
16615 /// directories, and removable volumes.
16616 ///
16617 ///Sends a `POST` request to `/core/disks`
16618 ///
16619 ///Arguments:
16620 /// - `async_`: Run the command asynchronously. Returns a job id
16621 /// immediately.
16622 /// - `group`: Assign the request to a custom stats group.
16623 /// - `body`
16624 pub async fn core_disks<'a>(
16625 &'a self,
16626 async_: Option<bool>,
16627 group: Option<&'a str>,
16628 body: &'a types::CoreDisksRequest,
16629 ) -> Result<ResponseValue<types::CoreDisksResponse>, Error<types::RcError>> {
16630 let url = format!("{}/core/disks", self.baseurl,);
16631 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16632 header_map.append(
16633 ::reqwest::header::HeaderName::from_static("api-version"),
16634 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16635 );
16636 #[allow(unused_mut)]
16637 let mut request = self
16638 .client
16639 .post(url)
16640 .header(
16641 ::reqwest::header::ACCEPT,
16642 ::reqwest::header::HeaderValue::from_static("application/json"),
16643 )
16644 .json(&body)
16645 .query(&progenitor_client::QueryParam::new("_async", &async_))
16646 .query(&progenitor_client::QueryParam::new("_group", &group))
16647 .headers(header_map)
16648 .build()?;
16649 let info = OperationInfo {
16650 operation_id: "core_disks",
16651 };
16652 self.pre(&mut request, &info).await?;
16653 let result = self.exec(request, &info).await;
16654 self.post(&result, &info).await?;
16655 let response = result?;
16656 match response.status().as_u16() {
16657 200u16 => ResponseValue::from_response(response).await,
16658 400u16..=499u16 => Err(Error::ErrorResponse(
16659 ResponseValue::from_response(response).await?,
16660 )),
16661 500u16..=599u16 => Err(Error::ErrorResponse(
16662 ResponseValue::from_response(response).await?,
16663 )),
16664 _ => Err(Error::UnexpectedResponse(response)),
16665 }
16666 }
16667
16668 ///Report disk usage
16669 ///
16670 ///Returns disk usage statistics for the supplied local directory (defaults
16671 /// to the cache dir).
16672 ///
16673 ///Sends a `POST` request to `/core/du`
16674 ///
16675 ///Arguments:
16676 /// - `async_`: Run the command asynchronously. Returns a job id
16677 /// immediately.
16678 /// - `group`: Assign the request to a custom stats group.
16679 /// - `dir`: Local directory path to report disk usage for. Defaults to the
16680 /// rclone cache directory when omitted.
16681 /// - `body`
16682 pub async fn core_du<'a>(
16683 &'a self,
16684 async_: Option<bool>,
16685 group: Option<&'a str>,
16686 dir: Option<&'a str>,
16687 body: &'a types::CoreDuRequest,
16688 ) -> Result<ResponseValue<types::CoreDuResponse>, Error<types::RcError>> {
16689 let url = format!("{}/core/du", self.baseurl,);
16690 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16691 header_map.append(
16692 ::reqwest::header::HeaderName::from_static("api-version"),
16693 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16694 );
16695 #[allow(unused_mut)]
16696 let mut request = self
16697 .client
16698 .post(url)
16699 .header(
16700 ::reqwest::header::ACCEPT,
16701 ::reqwest::header::HeaderValue::from_static("application/json"),
16702 )
16703 .json(&body)
16704 .query(&progenitor_client::QueryParam::new("_async", &async_))
16705 .query(&progenitor_client::QueryParam::new("_group", &group))
16706 .query(&progenitor_client::QueryParam::new("dir", &dir))
16707 .headers(header_map)
16708 .build()?;
16709 let info = OperationInfo {
16710 operation_id: "core_du",
16711 };
16712 self.pre(&mut request, &info).await?;
16713 let result = self.exec(request, &info).await;
16714 self.post(&result, &info).await?;
16715 let response = result?;
16716 match response.status().as_u16() {
16717 200u16 => ResponseValue::from_response(response).await,
16718 400u16..=499u16 => Err(Error::ErrorResponse(
16719 ResponseValue::from_response(response).await?,
16720 )),
16721 500u16..=599u16 => Err(Error::ErrorResponse(
16722 ResponseValue::from_response(response).await?,
16723 )),
16724 _ => Err(Error::UnexpectedResponse(response)),
16725 }
16726 }
16727
16728 ///Force garbage collection
16729 ///
16730 ///Triggers Go's garbage collector to release unused memory.
16731 ///
16732 ///Sends a `POST` request to `/core/gc`
16733 ///
16734 ///Arguments:
16735 /// - `async_`: Run the command asynchronously. Returns a job id
16736 /// immediately.
16737 /// - `group`: Assign the request to a custom stats group.
16738 /// - `body`
16739 pub async fn core_gc<'a>(
16740 &'a self,
16741 async_: Option<bool>,
16742 group: Option<&'a str>,
16743 body: &'a types::CoreGcRequest,
16744 ) -> Result<ResponseValue<types::CoreGcResponse>, Error<types::RcError>> {
16745 let url = format!("{}/core/gc", self.baseurl,);
16746 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16747 header_map.append(
16748 ::reqwest::header::HeaderName::from_static("api-version"),
16749 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16750 );
16751 #[allow(unused_mut)]
16752 let mut request = self
16753 .client
16754 .post(url)
16755 .header(
16756 ::reqwest::header::ACCEPT,
16757 ::reqwest::header::HeaderValue::from_static("application/json"),
16758 )
16759 .json(&body)
16760 .query(&progenitor_client::QueryParam::new("_async", &async_))
16761 .query(&progenitor_client::QueryParam::new("_group", &group))
16762 .headers(header_map)
16763 .build()?;
16764 let info = OperationInfo {
16765 operation_id: "core_gc",
16766 };
16767 self.pre(&mut request, &info).await?;
16768 let result = self.exec(request, &info).await;
16769 self.post(&result, &info).await?;
16770 let response = result?;
16771 match response.status().as_u16() {
16772 200u16 => ResponseValue::from_response(response).await,
16773 400u16..=499u16 => Err(Error::ErrorResponse(
16774 ResponseValue::from_response(response).await?,
16775 )),
16776 500u16..=599u16 => Err(Error::ErrorResponse(
16777 ResponseValue::from_response(response).await?,
16778 )),
16779 _ => Err(Error::UnexpectedResponse(response)),
16780 }
16781 }
16782
16783 ///List stats groups
16784 ///
16785 ///Lists stats groups currently tracked by rclone.
16786 ///
16787 ///Sends a `POST` request to `/core/group-list`
16788 ///
16789 ///Arguments:
16790 /// - `async_`: Run the command asynchronously. Returns a job id
16791 /// immediately.
16792 /// - `group`: Assign the request to a custom stats group.
16793 /// - `body`
16794 pub async fn core_group_list<'a>(
16795 &'a self,
16796 async_: Option<bool>,
16797 group: Option<&'a str>,
16798 body: &'a types::CoreGroupListRequest,
16799 ) -> Result<ResponseValue<types::CoreGroupListResponse>, Error<types::RcError>> {
16800 let url = format!("{}/core/group-list", self.baseurl,);
16801 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16802 header_map.append(
16803 ::reqwest::header::HeaderName::from_static("api-version"),
16804 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16805 );
16806 #[allow(unused_mut)]
16807 let mut request = self
16808 .client
16809 .post(url)
16810 .header(
16811 ::reqwest::header::ACCEPT,
16812 ::reqwest::header::HeaderValue::from_static("application/json"),
16813 )
16814 .json(&body)
16815 .query(&progenitor_client::QueryParam::new("_async", &async_))
16816 .query(&progenitor_client::QueryParam::new("_group", &group))
16817 .headers(header_map)
16818 .build()?;
16819 let info = OperationInfo {
16820 operation_id: "core_group_list",
16821 };
16822 self.pre(&mut request, &info).await?;
16823 let result = self.exec(request, &info).await;
16824 self.post(&result, &info).await?;
16825 let response = result?;
16826 match response.status().as_u16() {
16827 200u16 => ResponseValue::from_response(response).await,
16828 400u16..=499u16 => Err(Error::ErrorResponse(
16829 ResponseValue::from_response(response).await?,
16830 )),
16831 500u16..=599u16 => Err(Error::ErrorResponse(
16832 ResponseValue::from_response(response).await?,
16833 )),
16834 _ => Err(Error::UnexpectedResponse(response)),
16835 }
16836 }
16837
16838 ///Fetch runtime memory stats
16839 ///
16840 ///Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
16841 ///
16842 ///Sends a `POST` request to `/core/memstats`
16843 ///
16844 ///Arguments:
16845 /// - `async_`: Run the command asynchronously. Returns a job id
16846 /// immediately.
16847 /// - `group`: Assign the request to a custom stats group.
16848 /// - `body`
16849 pub async fn core_memstats<'a>(
16850 &'a self,
16851 async_: Option<bool>,
16852 group: Option<&'a str>,
16853 body: &'a types::CoreMemstatsRequest,
16854 ) -> Result<
16855 ResponseValue<::std::collections::HashMap<::std::string::String, f64>>,
16856 Error<types::RcError>,
16857 > {
16858 let url = format!("{}/core/memstats", self.baseurl,);
16859 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16860 header_map.append(
16861 ::reqwest::header::HeaderName::from_static("api-version"),
16862 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16863 );
16864 #[allow(unused_mut)]
16865 let mut request = self
16866 .client
16867 .post(url)
16868 .header(
16869 ::reqwest::header::ACCEPT,
16870 ::reqwest::header::HeaderValue::from_static("application/json"),
16871 )
16872 .json(&body)
16873 .query(&progenitor_client::QueryParam::new("_async", &async_))
16874 .query(&progenitor_client::QueryParam::new("_group", &group))
16875 .headers(header_map)
16876 .build()?;
16877 let info = OperationInfo {
16878 operation_id: "core_memstats",
16879 };
16880 self.pre(&mut request, &info).await?;
16881 let result = self.exec(request, &info).await;
16882 self.post(&result, &info).await?;
16883 let response = result?;
16884 match response.status().as_u16() {
16885 200u16 => ResponseValue::from_response(response).await,
16886 400u16..=499u16 => Err(Error::ErrorResponse(
16887 ResponseValue::from_response(response).await?,
16888 )),
16889 500u16..=599u16 => Err(Error::ErrorResponse(
16890 ResponseValue::from_response(response).await?,
16891 )),
16892 _ => Err(Error::UnexpectedResponse(response)),
16893 }
16894 }
16895
16896 ///Obscure a clear string
16897 ///
16898 ///Obscures a plain-text secret for inclusion in `rclone.conf`.
16899 ///
16900 ///Sends a `POST` request to `/core/obscure`
16901 ///
16902 ///Arguments:
16903 /// - `async_`: Run the command asynchronously. Returns a job id
16904 /// immediately.
16905 /// - `group`: Assign the request to a custom stats group.
16906 /// - `clear`: Plain-text string to obscure for storage in the config file.
16907 /// - `body`
16908 pub async fn core_obscure<'a>(
16909 &'a self,
16910 async_: Option<bool>,
16911 group: Option<&'a str>,
16912 clear: Option<&'a str>,
16913 body: &'a types::CoreObscureRequest,
16914 ) -> Result<ResponseValue<types::CoreObscureResponse>, Error<types::RcError>> {
16915 let url = format!("{}/core/obscure", self.baseurl,);
16916 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16917 header_map.append(
16918 ::reqwest::header::HeaderName::from_static("api-version"),
16919 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16920 );
16921 #[allow(unused_mut)]
16922 let mut request = self
16923 .client
16924 .post(url)
16925 .header(
16926 ::reqwest::header::ACCEPT,
16927 ::reqwest::header::HeaderValue::from_static("application/json"),
16928 )
16929 .json(&body)
16930 .query(&progenitor_client::QueryParam::new("_async", &async_))
16931 .query(&progenitor_client::QueryParam::new("_group", &group))
16932 .query(&progenitor_client::QueryParam::new("clear", &clear))
16933 .headers(header_map)
16934 .build()?;
16935 let info = OperationInfo {
16936 operation_id: "core_obscure",
16937 };
16938 self.pre(&mut request, &info).await?;
16939 let result = self.exec(request, &info).await;
16940 self.post(&result, &info).await?;
16941 let response = result?;
16942 match response.status().as_u16() {
16943 200u16 => ResponseValue::from_response(response).await,
16944 400u16..=499u16 => Err(Error::ErrorResponse(
16945 ResponseValue::from_response(response).await?,
16946 )),
16947 500u16..=599u16 => Err(Error::ErrorResponse(
16948 ResponseValue::from_response(response).await?,
16949 )),
16950 _ => Err(Error::UnexpectedResponse(response)),
16951 }
16952 }
16953
16954 ///Return rclone PID
16955 ///
16956 ///Returns the process ID of the running rclone instance.
16957 ///
16958 ///Sends a `POST` request to `/core/pid`
16959 ///
16960 ///Arguments:
16961 /// - `async_`: Run the command asynchronously. Returns a job id
16962 /// immediately.
16963 /// - `group`: Assign the request to a custom stats group.
16964 /// - `body`
16965 pub async fn core_pid<'a>(
16966 &'a self,
16967 async_: Option<bool>,
16968 group: Option<&'a str>,
16969 body: &'a types::CorePidRequest,
16970 ) -> Result<ResponseValue<types::CorePidResponse>, Error<types::RcError>> {
16971 let url = format!("{}/core/pid", self.baseurl,);
16972 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
16973 header_map.append(
16974 ::reqwest::header::HeaderName::from_static("api-version"),
16975 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
16976 );
16977 #[allow(unused_mut)]
16978 let mut request = self
16979 .client
16980 .post(url)
16981 .header(
16982 ::reqwest::header::ACCEPT,
16983 ::reqwest::header::HeaderValue::from_static("application/json"),
16984 )
16985 .json(&body)
16986 .query(&progenitor_client::QueryParam::new("_async", &async_))
16987 .query(&progenitor_client::QueryParam::new("_group", &group))
16988 .headers(header_map)
16989 .build()?;
16990 let info = OperationInfo {
16991 operation_id: "core_pid",
16992 };
16993 self.pre(&mut request, &info).await?;
16994 let result = self.exec(request, &info).await;
16995 self.post(&result, &info).await?;
16996 let response = result?;
16997 match response.status().as_u16() {
16998 200u16 => ResponseValue::from_response(response).await,
16999 400u16..=499u16 => Err(Error::ErrorResponse(
17000 ResponseValue::from_response(response).await?,
17001 )),
17002 500u16..=599u16 => Err(Error::ErrorResponse(
17003 ResponseValue::from_response(response).await?,
17004 )),
17005 _ => Err(Error::UnexpectedResponse(response)),
17006 }
17007 }
17008
17009 ///Terminate rclone
17010 ///
17011 ///Stops the rclone process, optionally supplying an exit code.
17012 ///
17013 ///Sends a `POST` request to `/core/quit`
17014 ///
17015 ///Arguments:
17016 /// - `async_`: Run the command asynchronously. Returns a job id
17017 /// immediately.
17018 /// - `group`: Assign the request to a custom stats group.
17019 /// - `exit_code`: Optional exit code to use when terminating the rclone
17020 /// process.
17021 /// - `body`
17022 pub async fn core_quit<'a>(
17023 &'a self,
17024 async_: Option<bool>,
17025 group: Option<&'a str>,
17026 exit_code: Option<i64>,
17027 body: &'a types::CoreQuitRequest,
17028 ) -> Result<ResponseValue<types::CoreQuitResponse>, Error<types::RcError>> {
17029 let url = format!("{}/core/quit", self.baseurl,);
17030 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17031 header_map.append(
17032 ::reqwest::header::HeaderName::from_static("api-version"),
17033 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17034 );
17035 #[allow(unused_mut)]
17036 let mut request = self
17037 .client
17038 .post(url)
17039 .header(
17040 ::reqwest::header::ACCEPT,
17041 ::reqwest::header::HeaderValue::from_static("application/json"),
17042 )
17043 .json(&body)
17044 .query(&progenitor_client::QueryParam::new("_async", &async_))
17045 .query(&progenitor_client::QueryParam::new("_group", &group))
17046 .query(&progenitor_client::QueryParam::new("exitCode", &exit_code))
17047 .headers(header_map)
17048 .build()?;
17049 let info = OperationInfo {
17050 operation_id: "core_quit",
17051 };
17052 self.pre(&mut request, &info).await?;
17053 let result = self.exec(request, &info).await;
17054 self.post(&result, &info).await?;
17055 let response = result?;
17056 match response.status().as_u16() {
17057 200u16 => ResponseValue::from_response(response).await,
17058 400u16..=499u16 => Err(Error::ErrorResponse(
17059 ResponseValue::from_response(response).await?,
17060 )),
17061 500u16..=599u16 => Err(Error::ErrorResponse(
17062 ResponseValue::from_response(response).await?,
17063 )),
17064 _ => Err(Error::UnexpectedResponse(response)),
17065 }
17066 }
17067
17068 ///Delete stats group
17069 ///
17070 ///Deletes the counters associated with a specific stats group.
17071 ///
17072 ///Sends a `POST` request to `/core/stats-delete`
17073 ///
17074 ///Arguments:
17075 /// - `async_`: Run the command asynchronously. Returns a job id
17076 /// immediately.
17077 /// - `group`: Assign the request to a custom stats group.
17078 /// - `group`: Stats group identifier to remove.
17079 /// - `body`
17080 pub async fn core_stats_delete<'a>(
17081 &'a self,
17082 async_: Option<bool>,
17083 _group: Option<&'a str>,
17084 group: Option<&'a str>,
17085 body: &'a types::CoreStatsDeleteRequest
17086 ) -> Result<ResponseValue<types::CoreStatsDeleteResponse>, Error<types::RcError>> {
17087 let url = format!("{}/core/stats-delete", self.baseurl,);
17088 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17089 header_map.append(
17090 ::reqwest::header::HeaderName::from_static("api-version"),
17091 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17092 );
17093 #[allow(unused_mut)]
17094 let mut request = self
17095 .client
17096 .post(url)
17097 .header(
17098 ::reqwest::header::ACCEPT,
17099 ::reqwest::header::HeaderValue::from_static("application/json"),
17100 )
17101 .json(&body)
17102 .query(&progenitor_client::QueryParam::new("_async", &async_))
17103 .query(&progenitor_client::QueryParam::new("_group", &group))
17104 .query(&progenitor_client::QueryParam::new("group", &group))
17105 .headers(header_map)
17106 .build()?;
17107 let info = OperationInfo {
17108 operation_id: "core_stats_delete",
17109 };
17110 self.pre(&mut request, &info).await?;
17111 let result = self.exec(request, &info).await;
17112 self.post(&result, &info).await?;
17113 let response = result?;
17114 match response.status().as_u16() {
17115 200u16 => ResponseValue::from_response(response).await,
17116 400u16..=499u16 => Err(Error::ErrorResponse(
17117 ResponseValue::from_response(response).await?,
17118 )),
17119 500u16..=599u16 => Err(Error::ErrorResponse(
17120 ResponseValue::from_response(response).await?,
17121 )),
17122 _ => Err(Error::UnexpectedResponse(response)),
17123 }
17124 }
17125
17126 ///Reset stats counters
17127 ///
17128 ///Clears counters, errors, and finished transfers for the provided stats
17129 /// group or all groups.
17130 ///
17131 ///Sends a `POST` request to `/core/stats-reset`
17132 ///
17133 ///Arguments:
17134 /// - `async_`: Run the command asynchronously. Returns a job id
17135 /// immediately.
17136 /// - `group`: Assign the request to a custom stats group.
17137 /// - `group`: Stats group identifier whose counters should be reset. Leave
17138 /// unset to reset all groups.
17139 /// - `body`
17140 pub async fn core_stats_reset<'a>(
17141 &'a self,
17142 async_: Option<bool>,
17143 _group: Option<&'a str>,
17144 group: Option<&'a str>,
17145 body: &'a types::CoreStatsResetRequest
17146 ) -> Result<ResponseValue<types::CoreStatsResetResponse>, Error<types::RcError>> {
17147 let url = format!("{}/core/stats-reset", self.baseurl,);
17148 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17149 header_map.append(
17150 ::reqwest::header::HeaderName::from_static("api-version"),
17151 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17152 );
17153 #[allow(unused_mut)]
17154 let mut request = self
17155 .client
17156 .post(url)
17157 .header(
17158 ::reqwest::header::ACCEPT,
17159 ::reqwest::header::HeaderValue::from_static("application/json"),
17160 )
17161 .json(&body)
17162 .query(&progenitor_client::QueryParam::new("_async", &async_))
17163 .query(&progenitor_client::QueryParam::new("_group", &group))
17164 .query(&progenitor_client::QueryParam::new("group", &group))
17165 .headers(header_map)
17166 .build()?;
17167 let info = OperationInfo {
17168 operation_id: "core_stats_reset",
17169 };
17170 self.pre(&mut request, &info).await?;
17171 let result = self.exec(request, &info).await;
17172 self.post(&result, &info).await?;
17173 let response = result?;
17174 match response.status().as_u16() {
17175 200u16 => ResponseValue::from_response(response).await,
17176 400u16..=499u16 => Err(Error::ErrorResponse(
17177 ResponseValue::from_response(response).await?,
17178 )),
17179 500u16..=599u16 => Err(Error::ErrorResponse(
17180 ResponseValue::from_response(response).await?,
17181 )),
17182 _ => Err(Error::UnexpectedResponse(response)),
17183 }
17184 }
17185
17186 ///List completed transfers
17187 ///
17188 ///Returns up to 100 recently completed transfers for the requested stats
17189 /// group.
17190 ///
17191 ///Sends a `POST` request to `/core/transferred`
17192 ///
17193 ///Arguments:
17194 /// - `async_`: Run the command asynchronously. Returns a job id
17195 /// immediately.
17196 /// - `group`: Assign the request to a custom stats group.
17197 /// - `group`: Stats group identifier to filter the completed transfer list.
17198 /// Leave unset for all groups.
17199 /// - `body`
17200 pub async fn core_transferred<'a>(
17201 &'a self,
17202 async_: Option<bool>,
17203 _group: Option<&'a str>,
17204 group: Option<&'a str>,
17205 body: &'a types::CoreTransferredRequest
17206 ) -> Result<ResponseValue<types::CoreTransferredResponse>, Error<types::RcError>> {
17207 let url = format!("{}/core/transferred", self.baseurl,);
17208 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17209 header_map.append(
17210 ::reqwest::header::HeaderName::from_static("api-version"),
17211 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17212 );
17213 #[allow(unused_mut)]
17214 let mut request = self
17215 .client
17216 .post(url)
17217 .header(
17218 ::reqwest::header::ACCEPT,
17219 ::reqwest::header::HeaderValue::from_static("application/json"),
17220 )
17221 .json(&body)
17222 .query(&progenitor_client::QueryParam::new("_async", &async_))
17223 .query(&progenitor_client::QueryParam::new("_group", &group))
17224 .query(&progenitor_client::QueryParam::new("group", &group))
17225 .headers(header_map)
17226 .build()?;
17227 let info = OperationInfo {
17228 operation_id: "core_transferred",
17229 };
17230 self.pre(&mut request, &info).await?;
17231 let result = self.exec(request, &info).await;
17232 self.post(&result, &info).await?;
17233 let response = result?;
17234 match response.status().as_u16() {
17235 200u16 => ResponseValue::from_response(response).await,
17236 400u16..=499u16 => Err(Error::ErrorResponse(
17237 ResponseValue::from_response(response).await?,
17238 )),
17239 500u16..=599u16 => Err(Error::ErrorResponse(
17240 ResponseValue::from_response(response).await?,
17241 )),
17242 _ => Err(Error::UnexpectedResponse(response)),
17243 }
17244 }
17245
17246 ///Sends a `POST` request to `/debug/set-block-profile-rate`
17247 ///
17248 ///Arguments:
17249 /// - `async_`: Run the command asynchronously. Returns a job id
17250 /// immediately.
17251 /// - `group`: Assign the request to a custom stats group.
17252 /// - `rate`: Sampling interval in nanoseconds for blocking profile
17253 /// collection; use 1 to capture all events.
17254 /// - `body`
17255 pub async fn debug_set_block_profile_rate<'a>(
17256 &'a self,
17257 async_: Option<bool>,
17258 group: Option<&'a str>,
17259 rate: Option<i64>,
17260 body: &'a types::DebugSetBlockProfileRateRequest,
17261 ) -> Result<ResponseValue<types::DebugSetBlockProfileRateResponse>, Error<types::RcError>> {
17262 let url = format!("{}/debug/set-block-profile-rate", self.baseurl,);
17263 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17264 header_map.append(
17265 ::reqwest::header::HeaderName::from_static("api-version"),
17266 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17267 );
17268 #[allow(unused_mut)]
17269 let mut request = self
17270 .client
17271 .post(url)
17272 .header(
17273 ::reqwest::header::ACCEPT,
17274 ::reqwest::header::HeaderValue::from_static("application/json"),
17275 )
17276 .json(&body)
17277 .query(&progenitor_client::QueryParam::new("_async", &async_))
17278 .query(&progenitor_client::QueryParam::new("_group", &group))
17279 .query(&progenitor_client::QueryParam::new("rate", &rate))
17280 .headers(header_map)
17281 .build()?;
17282 let info = OperationInfo {
17283 operation_id: "debug_set_block_profile_rate",
17284 };
17285 self.pre(&mut request, &info).await?;
17286 let result = self.exec(request, &info).await;
17287 self.post(&result, &info).await?;
17288 let response = result?;
17289 match response.status().as_u16() {
17290 200u16 => ResponseValue::from_response(response).await,
17291 400u16..=499u16 => Err(Error::ErrorResponse(
17292 ResponseValue::from_response(response).await?,
17293 )),
17294 500u16..=599u16 => Err(Error::ErrorResponse(
17295 ResponseValue::from_response(response).await?,
17296 )),
17297 _ => Err(Error::UnexpectedResponse(response)),
17298 }
17299 }
17300
17301 ///Sends a `POST` request to `/debug/set-gc-percent`
17302 ///
17303 ///Arguments:
17304 /// - `async_`: Run the command asynchronously. Returns a job id
17305 /// immediately.
17306 /// - `group`: Assign the request to a custom stats group.
17307 /// - `gc_percent`: Target percentage of newly allocated data to trigger
17308 /// garbage collection.
17309 /// - `body`
17310 pub async fn debug_set_gc_percent<'a>(
17311 &'a self,
17312 async_: Option<bool>,
17313 group: Option<&'a str>,
17314 gc_percent: Option<i64>,
17315 body: &'a types::DebugSetGcPercentRequest,
17316 ) -> Result<ResponseValue<types::DebugSetGcPercentResponse>, Error<types::RcError>> {
17317 let url = format!("{}/debug/set-gc-percent", self.baseurl,);
17318 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17319 header_map.append(
17320 ::reqwest::header::HeaderName::from_static("api-version"),
17321 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17322 );
17323 #[allow(unused_mut)]
17324 let mut request = self
17325 .client
17326 .post(url)
17327 .header(
17328 ::reqwest::header::ACCEPT,
17329 ::reqwest::header::HeaderValue::from_static("application/json"),
17330 )
17331 .json(&body)
17332 .query(&progenitor_client::QueryParam::new("_async", &async_))
17333 .query(&progenitor_client::QueryParam::new("_group", &group))
17334 .query(&progenitor_client::QueryParam::new(
17335 "gc-percent",
17336 &gc_percent,
17337 ))
17338 .headers(header_map)
17339 .build()?;
17340 let info = OperationInfo {
17341 operation_id: "debug_set_gc_percent",
17342 };
17343 self.pre(&mut request, &info).await?;
17344 let result = self.exec(request, &info).await;
17345 self.post(&result, &info).await?;
17346 let response = result?;
17347 match response.status().as_u16() {
17348 200u16 => ResponseValue::from_response(response).await,
17349 400u16..=499u16 => Err(Error::ErrorResponse(
17350 ResponseValue::from_response(response).await?,
17351 )),
17352 500u16..=599u16 => Err(Error::ErrorResponse(
17353 ResponseValue::from_response(response).await?,
17354 )),
17355 _ => Err(Error::UnexpectedResponse(response)),
17356 }
17357 }
17358
17359 ///Sends a `POST` request to `/debug/set-mutex-profile-fraction`
17360 ///
17361 ///Arguments:
17362 /// - `async_`: Run the command asynchronously. Returns a job id
17363 /// immediately.
17364 /// - `group`: Assign the request to a custom stats group.
17365 /// - `rate`: Sampling fraction for mutex contention profiling; set to 0 to
17366 /// disable.
17367 /// - `body`
17368 pub async fn debug_set_mutex_profile_fraction<'a>(
17369 &'a self,
17370 async_: Option<bool>,
17371 group: Option<&'a str>,
17372 rate: Option<i64>,
17373 body: &'a types::DebugSetMutexProfileFractionRequest,
17374 ) -> Result<ResponseValue<types::DebugSetMutexProfileFractionResponse>, Error<types::RcError>>
17375 {
17376 let url = format!("{}/debug/set-mutex-profile-fraction", self.baseurl,);
17377 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17378 header_map.append(
17379 ::reqwest::header::HeaderName::from_static("api-version"),
17380 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17381 );
17382 #[allow(unused_mut)]
17383 let mut request = self
17384 .client
17385 .post(url)
17386 .header(
17387 ::reqwest::header::ACCEPT,
17388 ::reqwest::header::HeaderValue::from_static("application/json"),
17389 )
17390 .json(&body)
17391 .query(&progenitor_client::QueryParam::new("_async", &async_))
17392 .query(&progenitor_client::QueryParam::new("_group", &group))
17393 .query(&progenitor_client::QueryParam::new("rate", &rate))
17394 .headers(header_map)
17395 .build()?;
17396 let info = OperationInfo {
17397 operation_id: "debug_set_mutex_profile_fraction",
17398 };
17399 self.pre(&mut request, &info).await?;
17400 let result = self.exec(request, &info).await;
17401 self.post(&result, &info).await?;
17402 let response = result?;
17403 match response.status().as_u16() {
17404 200u16 => ResponseValue::from_response(response).await,
17405 400u16..=499u16 => Err(Error::ErrorResponse(
17406 ResponseValue::from_response(response).await?,
17407 )),
17408 500u16..=599u16 => Err(Error::ErrorResponse(
17409 ResponseValue::from_response(response).await?,
17410 )),
17411 _ => Err(Error::UnexpectedResponse(response)),
17412 }
17413 }
17414
17415 ///Sends a `POST` request to `/debug/set-soft-memory-limit`
17416 ///
17417 ///Arguments:
17418 /// - `async_`: Run the command asynchronously. Returns a job id
17419 /// immediately.
17420 /// - `group`: Assign the request to a custom stats group.
17421 /// - `mem_limit`: Soft memory limit for the Go runtime in bytes.
17422 /// - `body`
17423 pub async fn debug_set_soft_memory_limit<'a>(
17424 &'a self,
17425 async_: Option<bool>,
17426 group: Option<&'a str>,
17427 mem_limit: Option<i64>,
17428 body: &'a types::DebugSetSoftMemoryLimitRequest,
17429 ) -> Result<ResponseValue<types::DebugSetSoftMemoryLimitResponse>, Error<types::RcError>> {
17430 let url = format!("{}/debug/set-soft-memory-limit", self.baseurl,);
17431 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17432 header_map.append(
17433 ::reqwest::header::HeaderName::from_static("api-version"),
17434 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17435 );
17436 #[allow(unused_mut)]
17437 let mut request = self
17438 .client
17439 .post(url)
17440 .header(
17441 ::reqwest::header::ACCEPT,
17442 ::reqwest::header::HeaderValue::from_static("application/json"),
17443 )
17444 .json(&body)
17445 .query(&progenitor_client::QueryParam::new("_async", &async_))
17446 .query(&progenitor_client::QueryParam::new("_group", &group))
17447 .query(&progenitor_client::QueryParam::new("mem-limit", &mem_limit))
17448 .headers(header_map)
17449 .build()?;
17450 let info = OperationInfo {
17451 operation_id: "debug_set_soft_memory_limit",
17452 };
17453 self.pre(&mut request, &info).await?;
17454 let result = self.exec(request, &info).await;
17455 self.post(&result, &info).await?;
17456 let response = result?;
17457 match response.status().as_u16() {
17458 200u16 => ResponseValue::from_response(response).await,
17459 400u16..=499u16 => Err(Error::ErrorResponse(
17460 ResponseValue::from_response(response).await?,
17461 )),
17462 500u16..=599u16 => Err(Error::ErrorResponse(
17463 ResponseValue::from_response(response).await?,
17464 )),
17465 _ => Err(Error::UnexpectedResponse(response)),
17466 }
17467 }
17468
17469 ///Sends a `POST` request to `/fscache/clear`
17470 ///
17471 ///Arguments:
17472 /// - `async_`: Run the command asynchronously. Returns a job id
17473 /// immediately.
17474 /// - `group`: Assign the request to a custom stats group.
17475 /// - `body`
17476 pub async fn fscache_clear<'a>(
17477 &'a self,
17478 async_: Option<bool>,
17479 group: Option<&'a str>,
17480 body: &'a types::FscacheClearRequest,
17481 ) -> Result<ResponseValue<types::FscacheClearResponse>, Error<types::RcError>> {
17482 let url = format!("{}/fscache/clear", self.baseurl,);
17483 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17484 header_map.append(
17485 ::reqwest::header::HeaderName::from_static("api-version"),
17486 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17487 );
17488 #[allow(unused_mut)]
17489 let mut request = self
17490 .client
17491 .post(url)
17492 .header(
17493 ::reqwest::header::ACCEPT,
17494 ::reqwest::header::HeaderValue::from_static("application/json"),
17495 )
17496 .json(&body)
17497 .query(&progenitor_client::QueryParam::new("_async", &async_))
17498 .query(&progenitor_client::QueryParam::new("_group", &group))
17499 .headers(header_map)
17500 .build()?;
17501 let info = OperationInfo {
17502 operation_id: "fscache_clear",
17503 };
17504 self.pre(&mut request, &info).await?;
17505 let result = self.exec(request, &info).await;
17506 self.post(&result, &info).await?;
17507 let response = result?;
17508 match response.status().as_u16() {
17509 200u16 => ResponseValue::from_response(response).await,
17510 400u16..=499u16 => Err(Error::ErrorResponse(
17511 ResponseValue::from_response(response).await?,
17512 )),
17513 500u16..=599u16 => Err(Error::ErrorResponse(
17514 ResponseValue::from_response(response).await?,
17515 )),
17516 _ => Err(Error::UnexpectedResponse(response)),
17517 }
17518 }
17519
17520 ///Sends a `POST` request to `/fscache/entries`
17521 ///
17522 ///Arguments:
17523 /// - `async_`: Run the command asynchronously. Returns a job id
17524 /// immediately.
17525 /// - `group`: Assign the request to a custom stats group.
17526 /// - `body`
17527 pub async fn fscache_entries<'a>(
17528 &'a self,
17529 async_: Option<bool>,
17530 group: Option<&'a str>,
17531 body: &'a types::FscacheEntriesRequest,
17532 ) -> Result<ResponseValue<types::FscacheEntriesResponse>, Error<types::RcError>> {
17533 let url = format!("{}/fscache/entries", self.baseurl,);
17534 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17535 header_map.append(
17536 ::reqwest::header::HeaderName::from_static("api-version"),
17537 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17538 );
17539 #[allow(unused_mut)]
17540 let mut request = self
17541 .client
17542 .post(url)
17543 .header(
17544 ::reqwest::header::ACCEPT,
17545 ::reqwest::header::HeaderValue::from_static("application/json"),
17546 )
17547 .json(&body)
17548 .query(&progenitor_client::QueryParam::new("_async", &async_))
17549 .query(&progenitor_client::QueryParam::new("_group", &group))
17550 .headers(header_map)
17551 .build()?;
17552 let info = OperationInfo {
17553 operation_id: "fscache_entries",
17554 };
17555 self.pre(&mut request, &info).await?;
17556 let result = self.exec(request, &info).await;
17557 self.post(&result, &info).await?;
17558 let response = result?;
17559 match response.status().as_u16() {
17560 200u16 => ResponseValue::from_response(response).await,
17561 400u16..=499u16 => Err(Error::ErrorResponse(
17562 ResponseValue::from_response(response).await?,
17563 )),
17564 500u16..=599u16 => Err(Error::ErrorResponse(
17565 ResponseValue::from_response(response).await?,
17566 )),
17567 _ => Err(Error::UnexpectedResponse(response)),
17568 }
17569 }
17570
17571 ///Sends a `POST` request to `/mount/listmounts`
17572 ///
17573 ///Arguments:
17574 /// - `async_`: Run the command asynchronously. Returns a job id
17575 /// immediately.
17576 /// - `group`: Assign the request to a custom stats group.
17577 /// - `body`
17578 pub async fn mount_listmounts<'a>(
17579 &'a self,
17580 async_: Option<bool>,
17581 group: Option<&'a str>,
17582 body: &'a types::MountListmountsRequest,
17583 ) -> Result<ResponseValue<types::MountListmountsResponse>, Error<types::RcError>> {
17584 let url = format!("{}/mount/listmounts", self.baseurl,);
17585 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17586 header_map.append(
17587 ::reqwest::header::HeaderName::from_static("api-version"),
17588 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17589 );
17590 #[allow(unused_mut)]
17591 let mut request = self
17592 .client
17593 .post(url)
17594 .header(
17595 ::reqwest::header::ACCEPT,
17596 ::reqwest::header::HeaderValue::from_static("application/json"),
17597 )
17598 .json(&body)
17599 .query(&progenitor_client::QueryParam::new("_async", &async_))
17600 .query(&progenitor_client::QueryParam::new("_group", &group))
17601 .headers(header_map)
17602 .build()?;
17603 let info = OperationInfo {
17604 operation_id: "mount_listmounts",
17605 };
17606 self.pre(&mut request, &info).await?;
17607 let result = self.exec(request, &info).await;
17608 self.post(&result, &info).await?;
17609 let response = result?;
17610 match response.status().as_u16() {
17611 200u16 => ResponseValue::from_response(response).await,
17612 400u16..=499u16 => Err(Error::ErrorResponse(
17613 ResponseValue::from_response(response).await?,
17614 )),
17615 500u16..=599u16 => Err(Error::ErrorResponse(
17616 ResponseValue::from_response(response).await?,
17617 )),
17618 _ => Err(Error::UnexpectedResponse(response)),
17619 }
17620 }
17621
17622 ///Sends a `POST` request to `/mount/mount`
17623 ///
17624 ///Arguments:
17625 /// - `async_`: Run the command asynchronously. Returns a job id
17626 /// immediately.
17627 /// - `config`: JSON encoded config overrides applied for this call only.
17628 /// - `filter`: JSON encoded filter overrides applied for this call only.
17629 /// - `group`: Assign the request to a custom stats group.
17630 /// - `fs`: Remote path to mount, such as `drive:` or `remote:subdir`.
17631 /// - `mount_opt`: Mount options encoded as JSON, matching flags accepted by
17632 /// `rclone mount`.
17633 /// - `mount_point`: Absolute local path where the remote should be mounted.
17634 /// - `mount_type`: Optional mount implementation to use (`mount`, `cmount`,
17635 /// or `mount2`).
17636 /// - `vfs_opt`: VFS options encoded as JSON, matching flags accepted by
17637 /// `rclone mount`.
17638 /// - `body`
17639 pub async fn mount_mount<'a>(
17640 &'a self,
17641 async_: Option<bool>,
17642 config: Option<&'a str>,
17643 filter: Option<&'a str>,
17644 group: Option<&'a str>,
17645 fs: Option<&'a str>,
17646 mount_opt: Option<&'a str>,
17647 mount_point: Option<&'a str>,
17648 mount_type: Option<&'a str>,
17649 vfs_opt: Option<&'a str>,
17650 body: &'a types::MountMountRequest,
17651 ) -> Result<ResponseValue<types::MountMountResponse>, Error<types::RcError>> {
17652 let url = format!("{}/mount/mount", self.baseurl,);
17653 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17654 header_map.append(
17655 ::reqwest::header::HeaderName::from_static("api-version"),
17656 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17657 );
17658 #[allow(unused_mut)]
17659 let mut request = self
17660 .client
17661 .post(url)
17662 .header(
17663 ::reqwest::header::ACCEPT,
17664 ::reqwest::header::HeaderValue::from_static("application/json"),
17665 )
17666 .json(&body)
17667 .query(&progenitor_client::QueryParam::new("_async", &async_))
17668 .query(&progenitor_client::QueryParam::new("_config", &config))
17669 .query(&progenitor_client::QueryParam::new("_filter", &filter))
17670 .query(&progenitor_client::QueryParam::new("_group", &group))
17671 .query(&progenitor_client::QueryParam::new("fs", &fs))
17672 .query(&progenitor_client::QueryParam::new("mountOpt", &mount_opt))
17673 .query(&progenitor_client::QueryParam::new(
17674 "mountPoint",
17675 &mount_point,
17676 ))
17677 .query(&progenitor_client::QueryParam::new(
17678 "mountType",
17679 &mount_type,
17680 ))
17681 .query(&progenitor_client::QueryParam::new("vfsOpt", &vfs_opt))
17682 .headers(header_map)
17683 .build()?;
17684 let info = OperationInfo {
17685 operation_id: "mount_mount",
17686 };
17687 self.pre(&mut request, &info).await?;
17688 let result = self.exec(request, &info).await;
17689 self.post(&result, &info).await?;
17690 let response = result?;
17691 match response.status().as_u16() {
17692 200u16 => ResponseValue::from_response(response).await,
17693 400u16..=499u16 => Err(Error::ErrorResponse(
17694 ResponseValue::from_response(response).await?,
17695 )),
17696 500u16..=599u16 => Err(Error::ErrorResponse(
17697 ResponseValue::from_response(response).await?,
17698 )),
17699 _ => Err(Error::UnexpectedResponse(response)),
17700 }
17701 }
17702
17703 ///Sends a `POST` request to `/mount/types`
17704 ///
17705 ///Arguments:
17706 /// - `async_`: Run the command asynchronously. Returns a job id
17707 /// immediately.
17708 /// - `group`: Assign the request to a custom stats group.
17709 /// - `body`
17710 pub async fn mount_types<'a>(
17711 &'a self,
17712 async_: Option<bool>,
17713 group: Option<&'a str>,
17714 body: &'a types::MountTypesRequest,
17715 ) -> Result<ResponseValue<types::MountTypesResponse>, Error<types::RcError>> {
17716 let url = format!("{}/mount/types", self.baseurl,);
17717 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17718 header_map.append(
17719 ::reqwest::header::HeaderName::from_static("api-version"),
17720 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17721 );
17722 #[allow(unused_mut)]
17723 let mut request = self
17724 .client
17725 .post(url)
17726 .header(
17727 ::reqwest::header::ACCEPT,
17728 ::reqwest::header::HeaderValue::from_static("application/json"),
17729 )
17730 .json(&body)
17731 .query(&progenitor_client::QueryParam::new("_async", &async_))
17732 .query(&progenitor_client::QueryParam::new("_group", &group))
17733 .headers(header_map)
17734 .build()?;
17735 let info = OperationInfo {
17736 operation_id: "mount_types",
17737 };
17738 self.pre(&mut request, &info).await?;
17739 let result = self.exec(request, &info).await;
17740 self.post(&result, &info).await?;
17741 let response = result?;
17742 match response.status().as_u16() {
17743 200u16 => ResponseValue::from_response(response).await,
17744 400u16..=499u16 => Err(Error::ErrorResponse(
17745 ResponseValue::from_response(response).await?,
17746 )),
17747 500u16..=599u16 => Err(Error::ErrorResponse(
17748 ResponseValue::from_response(response).await?,
17749 )),
17750 _ => Err(Error::UnexpectedResponse(response)),
17751 }
17752 }
17753
17754 ///Sends a `POST` request to `/mount/unmount`
17755 ///
17756 ///Arguments:
17757 /// - `async_`: Run the command asynchronously. Returns a job id
17758 /// immediately.
17759 /// - `group`: Assign the request to a custom stats group.
17760 /// - `mount_point`: Local mount point path to unmount.
17761 /// - `body`
17762 pub async fn mount_unmount<'a>(
17763 &'a self,
17764 async_: Option<bool>,
17765 group: Option<&'a str>,
17766 mount_point: Option<&'a str>,
17767 body: &'a types::MountUnmountRequest,
17768 ) -> Result<ResponseValue<types::MountUnmountResponse>, Error<types::RcError>> {
17769 let url = format!("{}/mount/unmount", self.baseurl,);
17770 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17771 header_map.append(
17772 ::reqwest::header::HeaderName::from_static("api-version"),
17773 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17774 );
17775 #[allow(unused_mut)]
17776 let mut request = self
17777 .client
17778 .post(url)
17779 .header(
17780 ::reqwest::header::ACCEPT,
17781 ::reqwest::header::HeaderValue::from_static("application/json"),
17782 )
17783 .json(&body)
17784 .query(&progenitor_client::QueryParam::new("_async", &async_))
17785 .query(&progenitor_client::QueryParam::new("_group", &group))
17786 .query(&progenitor_client::QueryParam::new(
17787 "mountPoint",
17788 &mount_point,
17789 ))
17790 .headers(header_map)
17791 .build()?;
17792 let info = OperationInfo {
17793 operation_id: "mount_unmount",
17794 };
17795 self.pre(&mut request, &info).await?;
17796 let result = self.exec(request, &info).await;
17797 self.post(&result, &info).await?;
17798 let response = result?;
17799 match response.status().as_u16() {
17800 200u16 => ResponseValue::from_response(response).await,
17801 400u16..=499u16 => Err(Error::ErrorResponse(
17802 ResponseValue::from_response(response).await?,
17803 )),
17804 500u16..=599u16 => Err(Error::ErrorResponse(
17805 ResponseValue::from_response(response).await?,
17806 )),
17807 _ => Err(Error::UnexpectedResponse(response)),
17808 }
17809 }
17810
17811 ///Sends a `POST` request to `/mount/unmountall`
17812 ///
17813 ///Arguments:
17814 /// - `async_`: Run the command asynchronously. Returns a job id
17815 /// immediately.
17816 /// - `group`: Assign the request to a custom stats group.
17817 /// - `body`
17818 pub async fn mount_unmountall<'a>(
17819 &'a self,
17820 async_: Option<bool>,
17821 group: Option<&'a str>,
17822 body: &'a types::MountUnmountallRequest,
17823 ) -> Result<ResponseValue<types::MountUnmountallResponse>, Error<types::RcError>> {
17824 let url = format!("{}/mount/unmountall", self.baseurl,);
17825 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17826 header_map.append(
17827 ::reqwest::header::HeaderName::from_static("api-version"),
17828 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17829 );
17830 #[allow(unused_mut)]
17831 let mut request = self
17832 .client
17833 .post(url)
17834 .header(
17835 ::reqwest::header::ACCEPT,
17836 ::reqwest::header::HeaderValue::from_static("application/json"),
17837 )
17838 .json(&body)
17839 .query(&progenitor_client::QueryParam::new("_async", &async_))
17840 .query(&progenitor_client::QueryParam::new("_group", &group))
17841 .headers(header_map)
17842 .build()?;
17843 let info = OperationInfo {
17844 operation_id: "mount_unmountall",
17845 };
17846 self.pre(&mut request, &info).await?;
17847 let result = self.exec(request, &info).await;
17848 self.post(&result, &info).await?;
17849 let response = result?;
17850 match response.status().as_u16() {
17851 200u16 => ResponseValue::from_response(response).await,
17852 400u16..=499u16 => Err(Error::ErrorResponse(
17853 ResponseValue::from_response(response).await?,
17854 )),
17855 500u16..=599u16 => Err(Error::ErrorResponse(
17856 ResponseValue::from_response(response).await?,
17857 )),
17858 _ => Err(Error::UnexpectedResponse(response)),
17859 }
17860 }
17861
17862 ///Echo parameters (auth required)
17863 ///
17864 ///Same as `rc/noop`, but requires authentication to validate access
17865 /// control.
17866 ///
17867 ///Sends a `POST` request to `/rc/noopauth`
17868 ///
17869 ///Arguments:
17870 /// - `async_`: Run the command asynchronously. Returns a job id
17871 /// immediately.
17872 /// - `params`: Additional arbitrary parameters allowed.
17873 /// - `body`
17874 pub async fn rc_noop_auth<'a>(
17875 &'a self,
17876 async_: Option<bool>,
17877 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
17878 body: &'a types::RcNoopAuthRequest,
17879 ) -> Result<
17880 ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
17881 Error<types::RcError>,
17882 > {
17883 let url = format!("{}/rc/noopauth", self.baseurl,);
17884 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17885 header_map.append(
17886 ::reqwest::header::HeaderName::from_static("api-version"),
17887 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17888 );
17889 #[allow(unused_mut)]
17890 let mut request = self
17891 .client
17892 .post(url)
17893 .header(
17894 ::reqwest::header::ACCEPT,
17895 ::reqwest::header::HeaderValue::from_static("application/json"),
17896 )
17897 .json(&body)
17898 .query(&progenitor_client::QueryParam::new("_async", &async_))
17899 .query(&progenitor_client::QueryParam::new("params", ¶ms))
17900 .headers(header_map)
17901 .build()?;
17902 let info = OperationInfo {
17903 operation_id: "rc_noop_auth",
17904 };
17905 self.pre(&mut request, &info).await?;
17906 let result = self.exec(request, &info).await;
17907 self.post(&result, &info).await?;
17908 let response = result?;
17909 match response.status().as_u16() {
17910 200u16 => ResponseValue::from_response(response).await,
17911 400u16..=499u16 => Err(Error::ErrorResponse(
17912 ResponseValue::from_response(response).await?,
17913 )),
17914 500u16..=599u16 => Err(Error::ErrorResponse(
17915 ResponseValue::from_response(response).await?,
17916 )),
17917 _ => Err(Error::UnexpectedResponse(response)),
17918 }
17919 }
17920
17921 ///Return a test error
17922 ///
17923 ///Always returns an error response incorporating the supplied parameters,
17924 /// useful for testing error handling.
17925 ///
17926 ///Sends a `POST` request to `/rc/error`
17927 ///
17928 ///Arguments:
17929 /// - `async_`: Run the command asynchronously. Returns a job id
17930 /// immediately.
17931 /// - `params`: Additional arbitrary parameters allowed.
17932 /// - `body`
17933 pub async fn rc_error<'a>(
17934 &'a self,
17935 async_: Option<bool>,
17936 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
17937 body: &'a types::RcErrorRequest,
17938 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
17939 let url = format!("{}/rc/error", self.baseurl,);
17940 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17941 header_map.append(
17942 ::reqwest::header::HeaderName::from_static("api-version"),
17943 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
17944 );
17945 #[allow(unused_mut)]
17946 let mut request = self
17947 .client
17948 .post(url)
17949 .header(
17950 ::reqwest::header::ACCEPT,
17951 ::reqwest::header::HeaderValue::from_static("application/json"),
17952 )
17953 .json(&body)
17954 .query(&progenitor_client::QueryParam::new("_async", &async_))
17955 .query(&progenitor_client::QueryParam::new("params", ¶ms))
17956 .headers(header_map)
17957 .build()?;
17958 let info = OperationInfo {
17959 operation_id: "rc_error",
17960 };
17961 self.pre(&mut request, &info).await?;
17962 let result = self.exec(request, &info).await;
17963 self.post(&result, &info).await?;
17964 let response = result?;
17965 match response.status().as_u16() {
17966 200u16 => Ok(ResponseValue::empty(response)),
17967 400u16..=499u16 => Err(Error::ErrorResponse(
17968 ResponseValue::from_response(response).await?,
17969 )),
17970 500u16..=599u16 => Err(Error::ErrorResponse(
17971 ResponseValue::from_response(response).await?,
17972 )),
17973 _ => Err(Error::UnexpectedResponse(response)),
17974 }
17975 }
17976
17977 ///List RC commands
17978 ///
17979 ///Returns metadata about every available RC command, including whether
17980 /// authentication is required.
17981 ///
17982 ///Sends a `POST` request to `/rc/list`
17983 ///
17984 ///Arguments:
17985 /// - `async_`: Run the command asynchronously. Returns a job id
17986 /// immediately.
17987 /// - `group`: Assign the request to a custom stats group.
17988 /// - `body`
17989 pub async fn rc_list<'a>(
17990 &'a self,
17991 async_: Option<bool>,
17992 group: Option<&'a str>,
17993 body: &'a types::RcListRequest,
17994 ) -> Result<ResponseValue<types::RcListResponse>, Error<types::RcError>> {
17995 let url = format!("{}/rc/list", self.baseurl,);
17996 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
17997 header_map.append(
17998 ::reqwest::header::HeaderName::from_static("api-version"),
17999 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18000 );
18001 #[allow(unused_mut)]
18002 let mut request = self
18003 .client
18004 .post(url)
18005 .header(
18006 ::reqwest::header::ACCEPT,
18007 ::reqwest::header::HeaderValue::from_static("application/json"),
18008 )
18009 .json(&body)
18010 .query(&progenitor_client::QueryParam::new("_async", &async_))
18011 .query(&progenitor_client::QueryParam::new("_group", &group))
18012 .headers(header_map)
18013 .build()?;
18014 let info = OperationInfo {
18015 operation_id: "rc_list",
18016 };
18017 self.pre(&mut request, &info).await?;
18018 let result = self.exec(request, &info).await;
18019 self.post(&result, &info).await?;
18020 let response = result?;
18021 match response.status().as_u16() {
18022 200u16 => ResponseValue::from_response(response).await,
18023 400u16..=499u16 => Err(Error::ErrorResponse(
18024 ResponseValue::from_response(response).await?,
18025 )),
18026 500u16..=599u16 => Err(Error::ErrorResponse(
18027 ResponseValue::from_response(response).await?,
18028 )),
18029 _ => Err(Error::UnexpectedResponse(response)),
18030 }
18031 }
18032
18033 ///Run backend command
18034 ///
18035 ///Invokes a backend-specific management command against an optional
18036 /// remote.
18037 ///
18038 ///Sends a `POST` request to `/backend/command`
18039 ///
18040 ///Arguments:
18041 /// - `async_`: Run the command asynchronously. Returns a job id
18042 /// immediately.
18043 /// - `group`: Assign the request to a custom stats group.
18044 /// - `arg`: Optional positional arguments for the backend command.
18045 /// - `command`: Backend-specific command to invoke.
18046 /// - `fs`: Remote name or path the backend command should target.
18047 /// - `opt`: Backend command options encoded as a JSON string.
18048 /// - `body`
18049 pub async fn backend_command<'a>(
18050 &'a self,
18051 async_: Option<bool>,
18052 group: Option<&'a str>,
18053 arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
18054 command: Option<&'a str>,
18055 fs: Option<&'a str>,
18056 opt: Option<&'a str>,
18057 body: &'a types::BackendCommandRequest,
18058 ) -> Result<ResponseValue<types::BackendCommandResponse>, Error<types::RcError>> {
18059 let url = format!("{}/backend/command", self.baseurl,);
18060 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18061 header_map.append(
18062 ::reqwest::header::HeaderName::from_static("api-version"),
18063 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18064 );
18065 #[allow(unused_mut)]
18066 let mut request = self
18067 .client
18068 .post(url)
18069 .header(
18070 ::reqwest::header::ACCEPT,
18071 ::reqwest::header::HeaderValue::from_static("application/json"),
18072 )
18073 .json(&body)
18074 .query(&progenitor_client::QueryParam::new("_async", &async_))
18075 .query(&progenitor_client::QueryParam::new("_group", &group))
18076 .query(&progenitor_client::QueryParam::new("arg", &arg))
18077 .query(&progenitor_client::QueryParam::new("command", &command))
18078 .query(&progenitor_client::QueryParam::new("fs", &fs))
18079 .query(&progenitor_client::QueryParam::new("opt", &opt))
18080 .headers(header_map)
18081 .build()?;
18082 let info = OperationInfo {
18083 operation_id: "backend_command",
18084 };
18085 self.pre(&mut request, &info).await?;
18086 let result = self.exec(request, &info).await;
18087 self.post(&result, &info).await?;
18088 let response = result?;
18089 match response.status().as_u16() {
18090 200u16 => ResponseValue::from_response(response).await,
18091 400u16..=499u16 => Err(Error::ErrorResponse(
18092 ResponseValue::from_response(response).await?,
18093 )),
18094 500u16..=599u16 => Err(Error::ErrorResponse(
18095 ResponseValue::from_response(response).await?,
18096 )),
18097 _ => Err(Error::UnexpectedResponse(response)),
18098 }
18099 }
18100
18101 ///Expire cache entries
18102 ///
18103 ///Drops cached directory entries, and optionally cached file data, for the
18104 /// cache backend.
18105 ///
18106 ///Sends a `POST` request to `/cache/expire`
18107 ///
18108 ///Arguments:
18109 /// - `async_`: Run the command asynchronously. Returns a job id
18110 /// immediately.
18111 /// - `group`: Assign the request to a custom stats group.
18112 /// - `remote`: Remote path to expire from the cache, e.g.
18113 /// `remote:path/to/dir`.
18114 /// - `with_data`: Set to true to drop cached chunk data along with
18115 /// directory entries.
18116 /// - `body`
18117 pub async fn cache_expire<'a>(
18118 &'a self,
18119 async_: Option<bool>,
18120 group: Option<&'a str>,
18121 remote: Option<&'a str>,
18122 with_data: Option<bool>,
18123 body: &'a types::CacheExpireRequest,
18124 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18125 let url = format!("{}/cache/expire", self.baseurl,);
18126 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18127 header_map.append(
18128 ::reqwest::header::HeaderName::from_static("api-version"),
18129 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18130 );
18131 #[allow(unused_mut)]
18132 let mut request = self
18133 .client
18134 .post(url)
18135 .header(
18136 ::reqwest::header::ACCEPT,
18137 ::reqwest::header::HeaderValue::from_static("application/json"),
18138 )
18139 .json(&body)
18140 .query(&progenitor_client::QueryParam::new("_async", &async_))
18141 .query(&progenitor_client::QueryParam::new("_group", &group))
18142 .query(&progenitor_client::QueryParam::new("remote", &remote))
18143 .query(&progenitor_client::QueryParam::new("withData", &with_data))
18144 .headers(header_map)
18145 .build()?;
18146 let info = OperationInfo {
18147 operation_id: "cache_expire",
18148 };
18149 self.pre(&mut request, &info).await?;
18150 let result = self.exec(request, &info).await;
18151 self.post(&result, &info).await?;
18152 let response = result?;
18153 match response.status().as_u16() {
18154 200u16 => Ok(ResponseValue::empty(response)),
18155 400u16..=499u16 => Err(Error::ErrorResponse(
18156 ResponseValue::from_response(response).await?,
18157 )),
18158 500u16..=599u16 => Err(Error::ErrorResponse(
18159 ResponseValue::from_response(response).await?,
18160 )),
18161 _ => Err(Error::UnexpectedResponse(response)),
18162 }
18163 }
18164
18165 ///Prefetch cache chunks
18166 ///
18167 ///Ensures specified file chunks are cached locally for a cache remote.
18168 ///
18169 ///Sends a `POST` request to `/cache/fetch`
18170 ///
18171 ///Arguments:
18172 /// - `async_`: Run the command asynchronously. Returns a job id
18173 /// immediately.
18174 /// - `group`: Assign the request to a custom stats group.
18175 /// - `chunks`: Comma-separated chunk specifier list (e.g. `0:10,25:30`)
18176 /// describing file pieces to prefetch.
18177 /// - `params`: Additional arbitrary parameters allowed.
18178 /// - `body`
18179 pub async fn cache_fetch<'a>(
18180 &'a self,
18181 async_: Option<bool>,
18182 group: Option<&'a str>,
18183 chunks: Option<&'a str>,
18184 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
18185 body: &'a types::CacheFetchRequest,
18186 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18187 let url = format!("{}/cache/fetch", self.baseurl,);
18188 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18189 header_map.append(
18190 ::reqwest::header::HeaderName::from_static("api-version"),
18191 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18192 );
18193 #[allow(unused_mut)]
18194 let mut request = self
18195 .client
18196 .post(url)
18197 .header(
18198 ::reqwest::header::ACCEPT,
18199 ::reqwest::header::HeaderValue::from_static("application/json"),
18200 )
18201 .json(&body)
18202 .query(&progenitor_client::QueryParam::new("_async", &async_))
18203 .query(&progenitor_client::QueryParam::new("_group", &group))
18204 .query(&progenitor_client::QueryParam::new("chunks", &chunks))
18205 .query(&progenitor_client::QueryParam::new("params", ¶ms))
18206 .headers(header_map)
18207 .build()?;
18208 let info = OperationInfo {
18209 operation_id: "cache_fetch",
18210 };
18211 self.pre(&mut request, &info).await?;
18212 let result = self.exec(request, &info).await;
18213 self.post(&result, &info).await?;
18214 let response = result?;
18215 match response.status().as_u16() {
18216 200u16 => Ok(ResponseValue::empty(response)),
18217 400u16..=499u16 => Err(Error::ErrorResponse(
18218 ResponseValue::from_response(response).await?,
18219 )),
18220 500u16..=599u16 => Err(Error::ErrorResponse(
18221 ResponseValue::from_response(response).await?,
18222 )),
18223 _ => Err(Error::UnexpectedResponse(response)),
18224 }
18225 }
18226
18227 ///Show cache stats
18228 ///
18229 ///Returns runtime statistics for the cache backend.
18230 ///
18231 ///Sends a `POST` request to `/cache/stats`
18232 ///
18233 ///Arguments:
18234 /// - `async_`: Run the command asynchronously. Returns a job id
18235 /// immediately.
18236 /// - `group`: Assign the request to a custom stats group.
18237 /// - `body`
18238 pub async fn cache_stats<'a>(
18239 &'a self,
18240 async_: Option<bool>,
18241 group: Option<&'a str>,
18242 body: &'a types::CacheStatsRequest,
18243 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18244 let url = format!("{}/cache/stats", self.baseurl,);
18245 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18246 header_map.append(
18247 ::reqwest::header::HeaderName::from_static("api-version"),
18248 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18249 );
18250 #[allow(unused_mut)]
18251 let mut request = self
18252 .client
18253 .post(url)
18254 .header(
18255 ::reqwest::header::ACCEPT,
18256 ::reqwest::header::HeaderValue::from_static("application/json"),
18257 )
18258 .json(&body)
18259 .query(&progenitor_client::QueryParam::new("_async", &async_))
18260 .query(&progenitor_client::QueryParam::new("_group", &group))
18261 .headers(header_map)
18262 .build()?;
18263 let info = OperationInfo {
18264 operation_id: "cache_stats",
18265 };
18266 self.pre(&mut request, &info).await?;
18267 let result = self.exec(request, &info).await;
18268 self.post(&result, &info).await?;
18269 let response = result?;
18270 match response.status().as_u16() {
18271 200u16 => Ok(ResponseValue::empty(response)),
18272 400u16..=499u16 => Err(Error::ErrorResponse(
18273 ResponseValue::from_response(response).await?,
18274 )),
18275 500u16..=599u16 => Err(Error::ErrorResponse(
18276 ResponseValue::from_response(response).await?,
18277 )),
18278 _ => Err(Error::UnexpectedResponse(response)),
18279 }
18280 }
18281
18282 ///Create remote configuration
18283 ///
18284 ///Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
18285 ///
18286 ///Sends a `POST` request to `/config/create`
18287 ///
18288 ///Arguments:
18289 /// - `async_`: Run the command asynchronously. Returns a job id
18290 /// immediately.
18291 /// - `group`: Assign the request to a custom stats group.
18292 /// - `name`: Name of the new remote configuration.
18293 /// - `opt`: Optional JSON object controlling interactive behaviour (e.g.
18294 /// `obscure`, `continue`).
18295 /// - `parameters`: JSON object of configuration key/value pairs required
18296 /// for the remote.
18297 /// - `type_`: Backend type identifier, such as `drive`, `s3`, or `dropbox`.
18298 /// - `body`
18299 pub async fn config_create<'a>(
18300 &'a self,
18301 async_: Option<bool>,
18302 group: Option<&'a str>,
18303 name: Option<&'a str>,
18304 opt: Option<&'a str>,
18305 parameters: Option<&'a str>,
18306 type_: Option<&'a str>,
18307 body: &'a types::ConfigCreateRequest,
18308 ) -> Result<ResponseValue<types::ConfigCreateResponse>, Error<types::RcError>> {
18309 let url = format!("{}/config/create", self.baseurl,);
18310 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18311 header_map.append(
18312 ::reqwest::header::HeaderName::from_static("api-version"),
18313 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18314 );
18315 #[allow(unused_mut)]
18316 let mut request = self
18317 .client
18318 .post(url)
18319 .header(
18320 ::reqwest::header::ACCEPT,
18321 ::reqwest::header::HeaderValue::from_static("application/json"),
18322 )
18323 .json(&body)
18324 .query(&progenitor_client::QueryParam::new("_async", &async_))
18325 .query(&progenitor_client::QueryParam::new("_group", &group))
18326 .query(&progenitor_client::QueryParam::new("name", &name))
18327 .query(&progenitor_client::QueryParam::new("opt", &opt))
18328 .query(&progenitor_client::QueryParam::new(
18329 "parameters",
18330 ¶meters,
18331 ))
18332 .query(&progenitor_client::QueryParam::new("type", &type_))
18333 .headers(header_map)
18334 .build()?;
18335 let info = OperationInfo {
18336 operation_id: "config_create",
18337 };
18338 self.pre(&mut request, &info).await?;
18339 let result = self.exec(request, &info).await;
18340 self.post(&result, &info).await?;
18341 let response = result?;
18342 match response.status().as_u16() {
18343 200u16 => ResponseValue::from_response(response).await,
18344 400u16..=499u16 => Err(Error::ErrorResponse(
18345 ResponseValue::from_response(response).await?,
18346 )),
18347 500u16..=599u16 => Err(Error::ErrorResponse(
18348 ResponseValue::from_response(response).await?,
18349 )),
18350 _ => Err(Error::UnexpectedResponse(response)),
18351 }
18352 }
18353
18354 ///Delete remote configuration
18355 ///
18356 ///Removes an existing remote from `rclone.conf`.
18357 ///
18358 ///Sends a `POST` request to `/config/delete`
18359 ///
18360 ///Arguments:
18361 /// - `async_`: Run the command asynchronously. Returns a job id
18362 /// immediately.
18363 /// - `group`: Assign the request to a custom stats group.
18364 /// - `name`: Name of the remote configuration to delete.
18365 /// - `body`
18366 pub async fn config_delete<'a>(
18367 &'a self,
18368 async_: Option<bool>,
18369 group: Option<&'a str>,
18370 name: Option<&'a str>,
18371 body: &'a types::ConfigDeleteRequest,
18372 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18373 let url = format!("{}/config/delete", self.baseurl,);
18374 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18375 header_map.append(
18376 ::reqwest::header::HeaderName::from_static("api-version"),
18377 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18378 );
18379 #[allow(unused_mut)]
18380 let mut request = self
18381 .client
18382 .post(url)
18383 .header(
18384 ::reqwest::header::ACCEPT,
18385 ::reqwest::header::HeaderValue::from_static("application/json"),
18386 )
18387 .json(&body)
18388 .query(&progenitor_client::QueryParam::new("_async", &async_))
18389 .query(&progenitor_client::QueryParam::new("_group", &group))
18390 .query(&progenitor_client::QueryParam::new("name", &name))
18391 .headers(header_map)
18392 .build()?;
18393 let info = OperationInfo {
18394 operation_id: "config_delete",
18395 };
18396 self.pre(&mut request, &info).await?;
18397 let result = self.exec(request, &info).await;
18398 self.post(&result, &info).await?;
18399 let response = result?;
18400 match response.status().as_u16() {
18401 200u16 => Ok(ResponseValue::empty(response)),
18402 400u16..=499u16 => Err(Error::ErrorResponse(
18403 ResponseValue::from_response(response).await?,
18404 )),
18405 500u16..=599u16 => Err(Error::ErrorResponse(
18406 ResponseValue::from_response(response).await?,
18407 )),
18408 _ => Err(Error::UnexpectedResponse(response)),
18409 }
18410 }
18411
18412 ///Dump configuration
18413 ///
18414 ///Returns the contents of the config file as a JSON object keyed by remote
18415 /// name.
18416 ///
18417 ///Sends a `POST` request to `/config/dump`
18418 ///
18419 ///Arguments:
18420 /// - `async_`: Run the command asynchronously. Returns a job id
18421 /// immediately.
18422 /// - `group`: Assign the request to a custom stats group.
18423 /// - `body`
18424 pub async fn config_dump<'a>(
18425 &'a self,
18426 async_: Option<bool>,
18427 group: Option<&'a str>,
18428 body: &'a types::ConfigDumpRequest,
18429 ) -> Result<
18430 ResponseValue<
18431 ::std::collections::HashMap<
18432 ::std::string::String,
18433 ::std::collections::HashMap<::std::string::String, ::std::string::String>,
18434 >,
18435 >,
18436 Error<types::RcError>,
18437 > {
18438 let url = format!("{}/config/dump", self.baseurl,);
18439 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18440 header_map.append(
18441 ::reqwest::header::HeaderName::from_static("api-version"),
18442 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18443 );
18444 #[allow(unused_mut)]
18445 let mut request = self
18446 .client
18447 .post(url)
18448 .header(
18449 ::reqwest::header::ACCEPT,
18450 ::reqwest::header::HeaderValue::from_static("application/json"),
18451 )
18452 .json(&body)
18453 .query(&progenitor_client::QueryParam::new("_async", &async_))
18454 .query(&progenitor_client::QueryParam::new("_group", &group))
18455 .headers(header_map)
18456 .build()?;
18457 let info = OperationInfo {
18458 operation_id: "config_dump",
18459 };
18460 self.pre(&mut request, &info).await?;
18461 let result = self.exec(request, &info).await;
18462 self.post(&result, &info).await?;
18463 let response = result?;
18464 match response.status().as_u16() {
18465 200u16 => ResponseValue::from_response(response).await,
18466 400u16..=499u16 => Err(Error::ErrorResponse(
18467 ResponseValue::from_response(response).await?,
18468 )),
18469 500u16..=599u16 => Err(Error::ErrorResponse(
18470 ResponseValue::from_response(response).await?,
18471 )),
18472 _ => Err(Error::UnexpectedResponse(response)),
18473 }
18474 }
18475
18476 ///Get remote configuration
18477 ///
18478 ///Returns the key/value settings for a single remote.
18479 ///
18480 ///Sends a `POST` request to `/config/get`
18481 ///
18482 ///Arguments:
18483 /// - `async_`: Run the command asynchronously. Returns a job id
18484 /// immediately.
18485 /// - `group`: Assign the request to a custom stats group.
18486 /// - `name`: Name of the remote configuration to fetch.
18487 /// - `body`
18488 pub async fn config_get<'a>(
18489 &'a self,
18490 async_: Option<bool>,
18491 group: Option<&'a str>,
18492 name: Option<&'a str>,
18493 body: &'a types::ConfigGetRequest,
18494 ) -> Result<ResponseValue<types::ConfigGetResponse>, Error<types::RcError>> {
18495 let url = format!("{}/config/get", self.baseurl,);
18496 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18497 header_map.append(
18498 ::reqwest::header::HeaderName::from_static("api-version"),
18499 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18500 );
18501 #[allow(unused_mut)]
18502 let mut request = self
18503 .client
18504 .post(url)
18505 .header(
18506 ::reqwest::header::ACCEPT,
18507 ::reqwest::header::HeaderValue::from_static("application/json"),
18508 )
18509 .json(&body)
18510 .query(&progenitor_client::QueryParam::new("_async", &async_))
18511 .query(&progenitor_client::QueryParam::new("_group", &group))
18512 .query(&progenitor_client::QueryParam::new("name", &name))
18513 .headers(header_map)
18514 .build()?;
18515 let info = OperationInfo {
18516 operation_id: "config_get",
18517 };
18518 self.pre(&mut request, &info).await?;
18519 let result = self.exec(request, &info).await;
18520 self.post(&result, &info).await?;
18521 let response = result?;
18522 match response.status().as_u16() {
18523 200u16 => ResponseValue::from_response(response).await,
18524 400u16..=499u16 => Err(Error::ErrorResponse(
18525 ResponseValue::from_response(response).await?,
18526 )),
18527 500u16..=599u16 => Err(Error::ErrorResponse(
18528 ResponseValue::from_response(response).await?,
18529 )),
18530 _ => Err(Error::UnexpectedResponse(response)),
18531 }
18532 }
18533
18534 ///List configured remotes
18535 ///
18536 ///Returns the names of all remotes defined in the config file.
18537 ///
18538 ///Sends a `POST` request to `/config/listremotes`
18539 ///
18540 ///Arguments:
18541 /// - `async_`: Run the command asynchronously. Returns a job id
18542 /// immediately.
18543 /// - `group`: Assign the request to a custom stats group.
18544 /// - `body`
18545 pub async fn config_listremotes<'a>(
18546 &'a self,
18547 async_: Option<bool>,
18548 group: Option<&'a str>,
18549 body: &'a types::ConfigListremotesRequest,
18550 ) -> Result<ResponseValue<types::ConfigListremotesResponse>, Error<types::RcError>> {
18551 let url = format!("{}/config/listremotes", self.baseurl,);
18552 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18553 header_map.append(
18554 ::reqwest::header::HeaderName::from_static("api-version"),
18555 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18556 );
18557 #[allow(unused_mut)]
18558 let mut request = self
18559 .client
18560 .post(url)
18561 .header(
18562 ::reqwest::header::ACCEPT,
18563 ::reqwest::header::HeaderValue::from_static("application/json"),
18564 )
18565 .json(&body)
18566 .query(&progenitor_client::QueryParam::new("_async", &async_))
18567 .query(&progenitor_client::QueryParam::new("_group", &group))
18568 .headers(header_map)
18569 .build()?;
18570 let info = OperationInfo {
18571 operation_id: "config_listremotes",
18572 };
18573 self.pre(&mut request, &info).await?;
18574 let result = self.exec(request, &info).await;
18575 self.post(&result, &info).await?;
18576 let response = result?;
18577 match response.status().as_u16() {
18578 200u16 => ResponseValue::from_response(response).await,
18579 400u16..=499u16 => Err(Error::ErrorResponse(
18580 ResponseValue::from_response(response).await?,
18581 )),
18582 500u16..=599u16 => Err(Error::ErrorResponse(
18583 ResponseValue::from_response(response).await?,
18584 )),
18585 _ => Err(Error::UnexpectedResponse(response)),
18586 }
18587 }
18588
18589 ///Update remote secrets
18590 ///
18591 ///Sets obscured password fields for a remote configuration.
18592 ///
18593 ///Sends a `POST` request to `/config/password`
18594 ///
18595 ///Arguments:
18596 /// - `async_`: Run the command asynchronously. Returns a job id
18597 /// immediately.
18598 /// - `group`: Assign the request to a custom stats group.
18599 /// - `name`: Name of the remote whose secrets should be updated.
18600 /// - `parameters`: JSON object of password answers, typically including
18601 /// `pass`.
18602 /// - `body`
18603 pub async fn config_password<'a>(
18604 &'a self,
18605 async_: Option<bool>,
18606 group: Option<&'a str>,
18607 name: Option<&'a str>,
18608 parameters: Option<&'a str>,
18609 body: &'a types::ConfigPasswordRequest,
18610 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18611 let url = format!("{}/config/password", self.baseurl,);
18612 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18613 header_map.append(
18614 ::reqwest::header::HeaderName::from_static("api-version"),
18615 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18616 );
18617 #[allow(unused_mut)]
18618 let mut request = self
18619 .client
18620 .post(url)
18621 .header(
18622 ::reqwest::header::ACCEPT,
18623 ::reqwest::header::HeaderValue::from_static("application/json"),
18624 )
18625 .json(&body)
18626 .query(&progenitor_client::QueryParam::new("_async", &async_))
18627 .query(&progenitor_client::QueryParam::new("_group", &group))
18628 .query(&progenitor_client::QueryParam::new("name", &name))
18629 .query(&progenitor_client::QueryParam::new(
18630 "parameters",
18631 ¶meters,
18632 ))
18633 .headers(header_map)
18634 .build()?;
18635 let info = OperationInfo {
18636 operation_id: "config_password",
18637 };
18638 self.pre(&mut request, &info).await?;
18639 let result = self.exec(request, &info).await;
18640 self.post(&result, &info).await?;
18641 let response = result?;
18642 match response.status().as_u16() {
18643 200u16 => Ok(ResponseValue::empty(response)),
18644 400u16..=499u16 => Err(Error::ErrorResponse(
18645 ResponseValue::from_response(response).await?,
18646 )),
18647 500u16..=599u16 => Err(Error::ErrorResponse(
18648 ResponseValue::from_response(response).await?,
18649 )),
18650 _ => Err(Error::UnexpectedResponse(response)),
18651 }
18652 }
18653
18654 ///Show config paths
18655 ///
18656 ///Returns the paths to the config file, cache directory, and temporary
18657 /// directory.
18658 ///
18659 ///Sends a `POST` request to `/config/paths`
18660 ///
18661 ///Arguments:
18662 /// - `async_`: Run the command asynchronously. Returns a job id
18663 /// immediately.
18664 /// - `group`: Assign the request to a custom stats group.
18665 /// - `body`
18666 pub async fn config_paths<'a>(
18667 &'a self,
18668 async_: Option<bool>,
18669 group: Option<&'a str>,
18670 body: &'a types::ConfigPathsRequest,
18671 ) -> Result<ResponseValue<types::ConfigPathsResponse>, Error<types::RcError>> {
18672 let url = format!("{}/config/paths", self.baseurl,);
18673 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18674 header_map.append(
18675 ::reqwest::header::HeaderName::from_static("api-version"),
18676 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18677 );
18678 #[allow(unused_mut)]
18679 let mut request = self
18680 .client
18681 .post(url)
18682 .header(
18683 ::reqwest::header::ACCEPT,
18684 ::reqwest::header::HeaderValue::from_static("application/json"),
18685 )
18686 .json(&body)
18687 .query(&progenitor_client::QueryParam::new("_async", &async_))
18688 .query(&progenitor_client::QueryParam::new("_group", &group))
18689 .headers(header_map)
18690 .build()?;
18691 let info = OperationInfo {
18692 operation_id: "config_paths",
18693 };
18694 self.pre(&mut request, &info).await?;
18695 let result = self.exec(request, &info).await;
18696 self.post(&result, &info).await?;
18697 let response = result?;
18698 match response.status().as_u16() {
18699 200u16 => ResponseValue::from_response(response).await,
18700 400u16..=499u16 => Err(Error::ErrorResponse(
18701 ResponseValue::from_response(response).await?,
18702 )),
18703 500u16..=599u16 => Err(Error::ErrorResponse(
18704 ResponseValue::from_response(response).await?,
18705 )),
18706 _ => Err(Error::UnexpectedResponse(response)),
18707 }
18708 }
18709
18710 ///List backend providers
18711 ///
18712 ///Returns metadata describing each supported storage provider.
18713 ///
18714 ///Sends a `POST` request to `/config/providers`
18715 ///
18716 ///Arguments:
18717 /// - `async_`: Run the command asynchronously. Returns a job id
18718 /// immediately.
18719 /// - `group`: Assign the request to a custom stats group.
18720 /// - `body`
18721 pub async fn config_providers<'a>(
18722 &'a self,
18723 async_: Option<bool>,
18724 group: Option<&'a str>,
18725 body: &'a types::ConfigProvidersRequest,
18726 ) -> Result<ResponseValue<types::ConfigProvidersResponse>, Error<types::RcError>> {
18727 let url = format!("{}/config/providers", self.baseurl,);
18728 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18729 header_map.append(
18730 ::reqwest::header::HeaderName::from_static("api-version"),
18731 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18732 );
18733 #[allow(unused_mut)]
18734 let mut request = self
18735 .client
18736 .post(url)
18737 .header(
18738 ::reqwest::header::ACCEPT,
18739 ::reqwest::header::HeaderValue::from_static("application/json"),
18740 )
18741 .json(&body)
18742 .query(&progenitor_client::QueryParam::new("_async", &async_))
18743 .query(&progenitor_client::QueryParam::new("_group", &group))
18744 .headers(header_map)
18745 .build()?;
18746 let info = OperationInfo {
18747 operation_id: "config_providers",
18748 };
18749 self.pre(&mut request, &info).await?;
18750 let result = self.exec(request, &info).await;
18751 self.post(&result, &info).await?;
18752 let response = result?;
18753 match response.status().as_u16() {
18754 200u16 => ResponseValue::from_response(response).await,
18755 400u16..=499u16 => Err(Error::ErrorResponse(
18756 ResponseValue::from_response(response).await?,
18757 )),
18758 500u16..=599u16 => Err(Error::ErrorResponse(
18759 ResponseValue::from_response(response).await?,
18760 )),
18761 _ => Err(Error::UnexpectedResponse(response)),
18762 }
18763 }
18764
18765 ///Set config path
18766 ///
18767 ///Points rclone at a specific `rclone.conf` file.
18768 ///
18769 ///Sends a `POST` request to `/config/setpath`
18770 ///
18771 ///Arguments:
18772 /// - `async_`: Run the command asynchronously. Returns a job id
18773 /// immediately.
18774 /// - `group`: Assign the request to a custom stats group.
18775 /// - `path`: Absolute path to the `rclone.conf` file that rclone should
18776 /// use.
18777 /// - `body`
18778 pub async fn config_setpath<'a>(
18779 &'a self,
18780 async_: Option<bool>,
18781 group: Option<&'a str>,
18782 path: Option<&'a str>,
18783 body: &'a types::ConfigSetpathRequest,
18784 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18785 let url = format!("{}/config/setpath", self.baseurl,);
18786 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18787 header_map.append(
18788 ::reqwest::header::HeaderName::from_static("api-version"),
18789 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18790 );
18791 #[allow(unused_mut)]
18792 let mut request = self
18793 .client
18794 .post(url)
18795 .header(
18796 ::reqwest::header::ACCEPT,
18797 ::reqwest::header::HeaderValue::from_static("application/json"),
18798 )
18799 .json(&body)
18800 .query(&progenitor_client::QueryParam::new("_async", &async_))
18801 .query(&progenitor_client::QueryParam::new("_group", &group))
18802 .query(&progenitor_client::QueryParam::new("path", &path))
18803 .headers(header_map)
18804 .build()?;
18805 let info = OperationInfo {
18806 operation_id: "config_setpath",
18807 };
18808 self.pre(&mut request, &info).await?;
18809 let result = self.exec(request, &info).await;
18810 self.post(&result, &info).await?;
18811 let response = result?;
18812 match response.status().as_u16() {
18813 200u16 => Ok(ResponseValue::empty(response)),
18814 400u16..=499u16 => Err(Error::ErrorResponse(
18815 ResponseValue::from_response(response).await?,
18816 )),
18817 500u16..=599u16 => Err(Error::ErrorResponse(
18818 ResponseValue::from_response(response).await?,
18819 )),
18820 _ => Err(Error::UnexpectedResponse(response)),
18821 }
18822 }
18823
18824 ///Unlock encrypted config
18825 ///
18826 ///Unlocks the configuration file using the provided password.
18827 ///
18828 ///Sends a `POST` request to `/config/unlock`
18829 ///
18830 ///Arguments:
18831 /// - `async_`: Run the command asynchronously. Returns a job id
18832 /// immediately.
18833 /// - `group`: Assign the request to a custom stats group.
18834 /// - `config_password`: Password used to unlock an encrypted config file.
18835 /// - `body`
18836 pub async fn config_unlock<'a>(
18837 &'a self,
18838 async_: Option<bool>,
18839 group: Option<&'a str>,
18840 config_password: Option<&'a str>,
18841 body: &'a types::ConfigUnlockRequest,
18842 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
18843 let url = format!("{}/config/unlock", self.baseurl,);
18844 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18845 header_map.append(
18846 ::reqwest::header::HeaderName::from_static("api-version"),
18847 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18848 );
18849 #[allow(unused_mut)]
18850 let mut request = self
18851 .client
18852 .post(url)
18853 .header(
18854 ::reqwest::header::ACCEPT,
18855 ::reqwest::header::HeaderValue::from_static("application/json"),
18856 )
18857 .json(&body)
18858 .query(&progenitor_client::QueryParam::new("_async", &async_))
18859 .query(&progenitor_client::QueryParam::new("_group", &group))
18860 .query(&progenitor_client::QueryParam::new(
18861 "configPassword",
18862 &config_password,
18863 ))
18864 .headers(header_map)
18865 .build()?;
18866 let info = OperationInfo {
18867 operation_id: "config_unlock",
18868 };
18869 self.pre(&mut request, &info).await?;
18870 let result = self.exec(request, &info).await;
18871 self.post(&result, &info).await?;
18872 let response = result?;
18873 match response.status().as_u16() {
18874 200u16 => Ok(ResponseValue::empty(response)),
18875 400u16..=499u16 => Err(Error::ErrorResponse(
18876 ResponseValue::from_response(response).await?,
18877 )),
18878 500u16..=599u16 => Err(Error::ErrorResponse(
18879 ResponseValue::from_response(response).await?,
18880 )),
18881 _ => Err(Error::UnexpectedResponse(response)),
18882 }
18883 }
18884
18885 ///Update remote configuration
18886 ///
18887 ///Updates an existing remote with new parameter values.
18888 ///
18889 ///Sends a `POST` request to `/config/update`
18890 ///
18891 ///Arguments:
18892 /// - `async_`: Run the command asynchronously. Returns a job id
18893 /// immediately.
18894 /// - `group`: Assign the request to a custom stats group.
18895 /// - `name`: Name of the remote configuration to update.
18896 /// - `opt`: Optional JSON object controlling update behaviour (e.g.
18897 /// `obscure`, `continue`).
18898 /// - `parameters`: JSON object of configuration key/value pairs to apply to
18899 /// the remote.
18900 /// - `body`
18901 pub async fn config_update<'a>(
18902 &'a self,
18903 async_: Option<bool>,
18904 group: Option<&'a str>,
18905 name: Option<&'a str>,
18906 opt: Option<&'a str>,
18907 parameters: Option<&'a str>,
18908 body: &'a types::ConfigUpdateRequest,
18909 ) -> Result<ResponseValue<types::ConfigUpdateResponse>, Error<types::RcError>> {
18910 let url = format!("{}/config/update", self.baseurl,);
18911 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18912 header_map.append(
18913 ::reqwest::header::HeaderName::from_static("api-version"),
18914 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18915 );
18916 #[allow(unused_mut)]
18917 let mut request = self
18918 .client
18919 .post(url)
18920 .header(
18921 ::reqwest::header::ACCEPT,
18922 ::reqwest::header::HeaderValue::from_static("application/json"),
18923 )
18924 .json(&body)
18925 .query(&progenitor_client::QueryParam::new("_async", &async_))
18926 .query(&progenitor_client::QueryParam::new("_group", &group))
18927 .query(&progenitor_client::QueryParam::new("name", &name))
18928 .query(&progenitor_client::QueryParam::new("opt", &opt))
18929 .query(&progenitor_client::QueryParam::new(
18930 "parameters",
18931 ¶meters,
18932 ))
18933 .headers(header_map)
18934 .build()?;
18935 let info = OperationInfo {
18936 operation_id: "config_update",
18937 };
18938 self.pre(&mut request, &info).await?;
18939 let result = self.exec(request, &info).await;
18940 self.post(&result, &info).await?;
18941 let response = result?;
18942 match response.status().as_u16() {
18943 200u16 => ResponseValue::from_response(response).await,
18944 400u16..=499u16 => Err(Error::ErrorResponse(
18945 ResponseValue::from_response(response).await?,
18946 )),
18947 500u16..=599u16 => Err(Error::ErrorResponse(
18948 ResponseValue::from_response(response).await?,
18949 )),
18950 _ => Err(Error::UnexpectedResponse(response)),
18951 }
18952 }
18953
18954 ///Report rclone version
18955 ///
18956 ///Returns the running rclone version, build metadata, and Go runtime
18957 /// details.
18958 ///
18959 ///Sends a `POST` request to `/core/version`
18960 ///
18961 ///Arguments:
18962 /// - `async_`: Run the command asynchronously. Returns a job id
18963 /// immediately.
18964 /// - `group`: Assign the request to a custom stats group.
18965 /// - `body`
18966 pub async fn core_version<'a>(
18967 &'a self,
18968 async_: Option<bool>,
18969 group: Option<&'a str>,
18970 body: &'a types::CoreVersionRequest,
18971 ) -> Result<ResponseValue<types::CoreVersionResponse>, Error<types::RcError>> {
18972 let url = format!("{}/core/version", self.baseurl,);
18973 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
18974 header_map.append(
18975 ::reqwest::header::HeaderName::from_static("api-version"),
18976 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
18977 );
18978 #[allow(unused_mut)]
18979 let mut request = self
18980 .client
18981 .post(url)
18982 .header(
18983 ::reqwest::header::ACCEPT,
18984 ::reqwest::header::HeaderValue::from_static("application/json"),
18985 )
18986 .json(&body)
18987 .query(&progenitor_client::QueryParam::new("_async", &async_))
18988 .query(&progenitor_client::QueryParam::new("_group", &group))
18989 .headers(header_map)
18990 .build()?;
18991 let info = OperationInfo {
18992 operation_id: "core_version",
18993 };
18994 self.pre(&mut request, &info).await?;
18995 let result = self.exec(request, &info).await;
18996 self.post(&result, &info).await?;
18997 let response = result?;
18998 match response.status().as_u16() {
18999 200u16 => ResponseValue::from_response(response).await,
19000 400u16..=499u16 => Err(Error::ErrorResponse(
19001 ResponseValue::from_response(response).await?,
19002 )),
19003 500u16..=599u16 => Err(Error::ErrorResponse(
19004 ResponseValue::from_response(response).await?,
19005 )),
19006 _ => Err(Error::UnexpectedResponse(response)),
19007 }
19008 }
19009
19010 ///Current stats snapshot
19011 ///
19012 ///Returns active transfer statistics including bytes transferred, speed,
19013 /// and error counts.
19014 ///
19015 ///Sends a `POST` request to `/core/stats`
19016 ///
19017 ///Arguments:
19018 /// - `async_`: Run the command asynchronously. Returns a job id
19019 /// immediately.
19020 /// - `group`: Assign the request to a custom stats group.
19021 /// - `group`: Stats group identifier to return a snapshot for. Leave unset
19022 /// to include all groups.
19023 /// - `short`: When true, omit the `transferring` and `checking` arrays from
19024 /// the response.
19025 /// - `body`
19026 pub async fn core_stats<'a>(
19027 &'a self,
19028 async_: Option<bool>,
19029 _group: Option<&'a str>,
19030 group: Option<&'a str>,
19031 short: Option<bool>,
19032 body: &'a types::CoreStatsRequest
19033 ) -> Result<ResponseValue<types::CoreStatsResponse>, Error<types::RcError>> {
19034 let url = format!("{}/core/stats", self.baseurl,);
19035 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19036 header_map.append(
19037 ::reqwest::header::HeaderName::from_static("api-version"),
19038 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19039 );
19040 #[allow(unused_mut)]
19041 let mut request = self
19042 .client
19043 .post(url)
19044 .header(
19045 ::reqwest::header::ACCEPT,
19046 ::reqwest::header::HeaderValue::from_static("application/json"),
19047 )
19048 .json(&body)
19049 .query(&progenitor_client::QueryParam::new("_async", &async_))
19050 .query(&progenitor_client::QueryParam::new("_group", &group))
19051 .query(&progenitor_client::QueryParam::new("group", &group))
19052 .query(&progenitor_client::QueryParam::new("short", &short))
19053 .headers(header_map)
19054 .build()?;
19055 let info = OperationInfo {
19056 operation_id: "core_stats",
19057 };
19058 self.pre(&mut request, &info).await?;
19059 let result = self.exec(request, &info).await;
19060 self.post(&result, &info).await?;
19061 let response = result?;
19062 match response.status().as_u16() {
19063 200u16 => ResponseValue::from_response(response).await,
19064 400u16..=499u16 => Err(Error::ErrorResponse(
19065 ResponseValue::from_response(response).await?,
19066 )),
19067 500u16..=599u16 => Err(Error::ErrorResponse(
19068 ResponseValue::from_response(response).await?,
19069 )),
19070 _ => Err(Error::UnexpectedResponse(response)),
19071 }
19072 }
19073
19074 ///Run batch of commands
19075 ///
19076 ///Run a batch of rclone rc commands concurrently.
19077 ///
19078 ///Sends a `POST` request to `/job/batch`
19079 ///
19080 ///Arguments:
19081 /// - `async_`: Run the command asynchronously. Returns a job id
19082 /// immediately.
19083 /// - `concurrency`: Do this many commands concurrently. Defaults to
19084 /// --transfers if not set.
19085 /// - `inputs`: List of inputs to the commands with an extra _path
19086 /// parameter.
19087 /// - `body`
19088 pub async fn job_batch<'a>(
19089 &'a self,
19090 async_: Option<bool>,
19091 concurrency: Option<i64>,
19092 inputs: Option<&'a ::std::vec::Vec<types::JobBatchInputsItem>>,
19093 body: &'a types::JobBatchRequest,
19094 ) -> Result<ResponseValue<types::JobBatchResponse>, Error<types::RcError>> {
19095 let url = format!("{}/job/batch", self.baseurl,);
19096 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19097 header_map.append(
19098 ::reqwest::header::HeaderName::from_static("api-version"),
19099 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19100 );
19101 #[allow(unused_mut)]
19102 let mut request = self
19103 .client
19104 .post(url)
19105 .header(
19106 ::reqwest::header::ACCEPT,
19107 ::reqwest::header::HeaderValue::from_static("application/json"),
19108 )
19109 .json(&body)
19110 .query(&progenitor_client::QueryParam::new("_async", &async_))
19111 .query(&progenitor_client::QueryParam::new(
19112 "concurrency",
19113 &concurrency,
19114 ))
19115 .query(&progenitor_client::QueryParam::new("inputs", &inputs))
19116 .headers(header_map)
19117 .build()?;
19118 let info = OperationInfo {
19119 operation_id: "job_batch",
19120 };
19121 self.pre(&mut request, &info).await?;
19122 let result = self.exec(request, &info).await;
19123 self.post(&result, &info).await?;
19124 let response = result?;
19125 match response.status().as_u16() {
19126 200u16 => ResponseValue::from_response(response).await,
19127 400u16..=499u16 => Err(Error::ErrorResponse(
19128 ResponseValue::from_response(response).await?,
19129 )),
19130 500u16..=599u16 => Err(Error::ErrorResponse(
19131 ResponseValue::from_response(response).await?,
19132 )),
19133 _ => Err(Error::UnexpectedResponse(response)),
19134 }
19135 }
19136
19137 ///List jobs
19138 ///
19139 ///Returns identifiers of active and recently completed asynchronous jobs.
19140 ///
19141 ///Sends a `POST` request to `/job/list`
19142 ///
19143 ///Arguments:
19144 /// - `async_`: Run the command asynchronously. Returns a job id
19145 /// immediately.
19146 /// - `body`
19147 pub async fn job_list<'a>(
19148 &'a self,
19149 async_: Option<bool>,
19150 body: &'a types::JobListRequest,
19151 ) -> Result<ResponseValue<types::JobListResponse>, Error<types::RcError>> {
19152 let url = format!("{}/job/list", self.baseurl,);
19153 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19154 header_map.append(
19155 ::reqwest::header::HeaderName::from_static("api-version"),
19156 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19157 );
19158 #[allow(unused_mut)]
19159 let mut request = self
19160 .client
19161 .post(url)
19162 .header(
19163 ::reqwest::header::ACCEPT,
19164 ::reqwest::header::HeaderValue::from_static("application/json"),
19165 )
19166 .json(&body)
19167 .query(&progenitor_client::QueryParam::new("_async", &async_))
19168 .headers(header_map)
19169 .build()?;
19170 let info = OperationInfo {
19171 operation_id: "job_list",
19172 };
19173 self.pre(&mut request, &info).await?;
19174 let result = self.exec(request, &info).await;
19175 self.post(&result, &info).await?;
19176 let response = result?;
19177 match response.status().as_u16() {
19178 200u16 => ResponseValue::from_response(response).await,
19179 400u16..=499u16 => Err(Error::ErrorResponse(
19180 ResponseValue::from_response(response).await?,
19181 )),
19182 500u16..=599u16 => Err(Error::ErrorResponse(
19183 ResponseValue::from_response(response).await?,
19184 )),
19185 _ => Err(Error::UnexpectedResponse(response)),
19186 }
19187 }
19188
19189 ///Get job status
19190 ///
19191 ///Returns timing, success state, output, and progress for a specific job.
19192 ///
19193 ///Sends a `POST` request to `/job/status`
19194 ///
19195 ///Arguments:
19196 /// - `async_`: Run the command asynchronously. Returns a job id
19197 /// immediately.
19198 /// - `jobid`: Numeric identifier of the job to query, as returned from an
19199 /// async call.
19200 /// - `body`
19201 pub async fn job_status<'a>(
19202 &'a self,
19203 async_: Option<bool>,
19204 jobid: Option<f64>,
19205 body: &'a types::JobStatusRequest,
19206 ) -> Result<ResponseValue<types::JobStatusResponse>, Error<types::RcError>> {
19207 let url = format!("{}/job/status", self.baseurl,);
19208 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19209 header_map.append(
19210 ::reqwest::header::HeaderName::from_static("api-version"),
19211 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19212 );
19213 #[allow(unused_mut)]
19214 let mut request = self
19215 .client
19216 .post(url)
19217 .header(
19218 ::reqwest::header::ACCEPT,
19219 ::reqwest::header::HeaderValue::from_static("application/json"),
19220 )
19221 .json(&body)
19222 .query(&progenitor_client::QueryParam::new("_async", &async_))
19223 .query(&progenitor_client::QueryParam::new("jobid", &jobid))
19224 .headers(header_map)
19225 .build()?;
19226 let info = OperationInfo {
19227 operation_id: "job_status",
19228 };
19229 self.pre(&mut request, &info).await?;
19230 let result = self.exec(request, &info).await;
19231 self.post(&result, &info).await?;
19232 let response = result?;
19233 match response.status().as_u16() {
19234 200u16 => ResponseValue::from_response(response).await,
19235 400u16..=499u16 => Err(Error::ErrorResponse(
19236 ResponseValue::from_response(response).await?,
19237 )),
19238 500u16..=599u16 => Err(Error::ErrorResponse(
19239 ResponseValue::from_response(response).await?,
19240 )),
19241 _ => Err(Error::UnexpectedResponse(response)),
19242 }
19243 }
19244
19245 ///Stop job
19246 ///
19247 ///Attempts to cancel a running job by ID.
19248 ///
19249 ///Sends a `POST` request to `/job/stop`
19250 ///
19251 ///Arguments:
19252 /// - `async_`: Run the command asynchronously. Returns a job id
19253 /// immediately.
19254 /// - `jobid`: Numeric identifier of the job to cancel.
19255 /// - `body`
19256 pub async fn job_stop<'a>(
19257 &'a self,
19258 async_: Option<bool>,
19259 jobid: Option<f64>,
19260 body: &'a types::JobStopRequest,
19261 ) -> Result<ResponseValue<types::JobStopResponse>, Error<types::RcError>> {
19262 let url = format!("{}/job/stop", self.baseurl,);
19263 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19264 header_map.append(
19265 ::reqwest::header::HeaderName::from_static("api-version"),
19266 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19267 );
19268 #[allow(unused_mut)]
19269 let mut request = self
19270 .client
19271 .post(url)
19272 .header(
19273 ::reqwest::header::ACCEPT,
19274 ::reqwest::header::HeaderValue::from_static("application/json"),
19275 )
19276 .json(&body)
19277 .query(&progenitor_client::QueryParam::new("_async", &async_))
19278 .query(&progenitor_client::QueryParam::new("jobid", &jobid))
19279 .headers(header_map)
19280 .build()?;
19281 let info = OperationInfo {
19282 operation_id: "job_stop",
19283 };
19284 self.pre(&mut request, &info).await?;
19285 let result = self.exec(request, &info).await;
19286 self.post(&result, &info).await?;
19287 let response = result?;
19288 match response.status().as_u16() {
19289 200u16 => ResponseValue::from_response(response).await,
19290 400u16..=499u16 => Err(Error::ErrorResponse(
19291 ResponseValue::from_response(response).await?,
19292 )),
19293 500u16..=599u16 => Err(Error::ErrorResponse(
19294 ResponseValue::from_response(response).await?,
19295 )),
19296 _ => Err(Error::UnexpectedResponse(response)),
19297 }
19298 }
19299
19300 ///Stop jobs in group
19301 ///
19302 ///Cancels all active jobs associated with the provided stats group.
19303 ///
19304 ///Sends a `POST` request to `/job/stopgroup`
19305 ///
19306 ///Arguments:
19307 /// - `async_`: Run the command asynchronously. Returns a job id
19308 /// immediately.
19309 /// - `group`: Stats group name whose active jobs should be stopped.
19310 /// - `body`
19311 pub async fn job_stopgroup<'a>(
19312 &'a self,
19313 async_: Option<bool>,
19314 group: Option<&'a str>,
19315 body: &'a types::JobStopgroupRequest,
19316 ) -> Result<ResponseValue<types::JobStopgroupResponse>, Error<types::RcError>> {
19317 let url = format!("{}/job/stopgroup", self.baseurl,);
19318 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19319 header_map.append(
19320 ::reqwest::header::HeaderName::from_static("api-version"),
19321 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19322 );
19323 #[allow(unused_mut)]
19324 let mut request = self
19325 .client
19326 .post(url)
19327 .header(
19328 ::reqwest::header::ACCEPT,
19329 ::reqwest::header::HeaderValue::from_static("application/json"),
19330 )
19331 .json(&body)
19332 .query(&progenitor_client::QueryParam::new("_async", &async_))
19333 .query(&progenitor_client::QueryParam::new("group", &group))
19334 .headers(header_map)
19335 .build()?;
19336 let info = OperationInfo {
19337 operation_id: "job_stopgroup",
19338 };
19339 self.pre(&mut request, &info).await?;
19340 let result = self.exec(request, &info).await;
19341 self.post(&result, &info).await?;
19342 let response = result?;
19343 match response.status().as_u16() {
19344 200u16 => ResponseValue::from_response(response).await,
19345 400u16..=499u16 => Err(Error::ErrorResponse(
19346 ResponseValue::from_response(response).await?,
19347 )),
19348 500u16..=599u16 => Err(Error::ErrorResponse(
19349 ResponseValue::from_response(response).await?,
19350 )),
19351 _ => Err(Error::UnexpectedResponse(response)),
19352 }
19353 }
19354
19355 ///List objects
19356 ///
19357 ///Lists objects and directories for a remote path, returning the same
19358 /// fields as `rclone lsjson`.
19359 ///
19360 ///Sends a `POST` request to `/operations/list`
19361 ///
19362 ///Arguments:
19363 /// - `async_`: Run the command asynchronously. Returns a job id
19364 /// immediately.
19365 /// - `group`: Assign the request to a custom stats group.
19366 /// - `dirs_only`: Set to true to return only directory entries.
19367 /// - `files_only`: Set to true to return only file entries.
19368 /// - `fs`: Remote name or path to list, for example `drive:`.
19369 /// - `hash_types`: Specify one or more hash algorithms to include when
19370 /// `showHash` is true (e.g. `md5`).
19371 /// - `metadata`: Set to true to include backend-provided metadata maps.
19372 /// - `no_mime_type`: Set to true to omit MIME type detection.
19373 /// - `no_mod_time`: Set to true to omit modification times for faster
19374 /// listings on some backends.
19375 /// - `opt`: Optional JSON-encoded object of listing flags (e.g. `{
19376 /// "recurse": true, "showHash": true }`).
19377 /// - `recurse`: Set to true to list directories recursively.
19378 /// - `remote`: Directory path within `fs` to list; leave empty to target
19379 /// the root.
19380 /// - `show_encrypted`: Set to true to include encrypted names when using
19381 /// crypt remotes.
19382 /// - `show_hash`: Set to true to include hash digests for each entry.
19383 /// - `show_orig_i_ds`: Set to true to include original backend identifiers
19384 /// where available.
19385 /// - `body`
19386 pub async fn operations_list<'a>(
19387 &'a self,
19388 async_: Option<bool>,
19389 group: Option<&'a str>,
19390 dirs_only: Option<bool>,
19391 files_only: Option<bool>,
19392 fs: Option<&'a str>,
19393 hash_types: Option<&'a ::std::vec::Vec<::std::string::String>>,
19394 metadata: Option<bool>,
19395 no_mime_type: Option<bool>,
19396 no_mod_time: Option<bool>,
19397 opt: Option<&'a str>,
19398 recurse: Option<bool>,
19399 remote: Option<&'a str>,
19400 show_encrypted: Option<bool>,
19401 show_hash: Option<bool>,
19402 show_orig_i_ds: Option<bool>,
19403 body: &'a types::OperationsListRequest,
19404 ) -> Result<ResponseValue<types::OperationsListResponse>, Error<types::RcError>> {
19405 let url = format!("{}/operations/list", self.baseurl,);
19406 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19407 header_map.append(
19408 ::reqwest::header::HeaderName::from_static("api-version"),
19409 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19410 );
19411 #[allow(unused_mut)]
19412 let mut request = self
19413 .client
19414 .post(url)
19415 .header(
19416 ::reqwest::header::ACCEPT,
19417 ::reqwest::header::HeaderValue::from_static("application/json"),
19418 )
19419 .json(&body)
19420 .query(&progenitor_client::QueryParam::new("_async", &async_))
19421 .query(&progenitor_client::QueryParam::new("_group", &group))
19422 .query(&progenitor_client::QueryParam::new("dirsOnly", &dirs_only))
19423 .query(&progenitor_client::QueryParam::new(
19424 "filesOnly",
19425 &files_only,
19426 ))
19427 .query(&progenitor_client::QueryParam::new("fs", &fs))
19428 .query(&progenitor_client::QueryParam::new(
19429 "hashTypes",
19430 &hash_types,
19431 ))
19432 .query(&progenitor_client::QueryParam::new("metadata", &metadata))
19433 .query(&progenitor_client::QueryParam::new(
19434 "noMimeType",
19435 &no_mime_type,
19436 ))
19437 .query(&progenitor_client::QueryParam::new(
19438 "noModTime",
19439 &no_mod_time,
19440 ))
19441 .query(&progenitor_client::QueryParam::new("opt", &opt))
19442 .query(&progenitor_client::QueryParam::new("recurse", &recurse))
19443 .query(&progenitor_client::QueryParam::new("remote", &remote))
19444 .query(&progenitor_client::QueryParam::new(
19445 "showEncrypted",
19446 &show_encrypted,
19447 ))
19448 .query(&progenitor_client::QueryParam::new("showHash", &show_hash))
19449 .query(&progenitor_client::QueryParam::new(
19450 "showOrigIDs",
19451 &show_orig_i_ds,
19452 ))
19453 .headers(header_map)
19454 .build()?;
19455 let info = OperationInfo {
19456 operation_id: "operations_list",
19457 };
19458 self.pre(&mut request, &info).await?;
19459 let result = self.exec(request, &info).await;
19460 self.post(&result, &info).await?;
19461 let response = result?;
19462 match response.status().as_u16() {
19463 200u16 => ResponseValue::from_response(response).await,
19464 400u16..=499u16 => Err(Error::ErrorResponse(
19465 ResponseValue::from_response(response).await?,
19466 )),
19467 500u16..=599u16 => Err(Error::ErrorResponse(
19468 ResponseValue::from_response(response).await?,
19469 )),
19470 _ => Err(Error::UnexpectedResponse(response)),
19471 }
19472 }
19473
19474 ///Stat an object
19475 ///
19476 ///Returns metadata for a single file or directory, mirroring `rclone
19477 /// lsjson` on one entry.
19478 ///
19479 ///Sends a `POST` request to `/operations/stat`
19480 ///
19481 ///Arguments:
19482 /// - `async_`: Run the command asynchronously. Returns a job id
19483 /// immediately.
19484 /// - `group`: Assign the request to a custom stats group.
19485 /// - `fs`: Remote name or path that contains the item to inspect.
19486 /// - `opt`: Optional JSON object of listing flags, matching those accepted
19487 /// by `operations/list`.
19488 /// - `remote`: Path to the file or directory within `fs` to describe.
19489 /// - `body`
19490 pub async fn operations_stat<'a>(
19491 &'a self,
19492 async_: Option<bool>,
19493 group: Option<&'a str>,
19494 fs: Option<&'a str>,
19495 opt: Option<&'a str>,
19496 remote: Option<&'a str>,
19497 body: &'a types::OperationsStatRequest,
19498 ) -> Result<ResponseValue<types::OperationsStatResponse>, Error<types::RcError>> {
19499 let url = format!("{}/operations/stat", self.baseurl,);
19500 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19501 header_map.append(
19502 ::reqwest::header::HeaderName::from_static("api-version"),
19503 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19504 );
19505 #[allow(unused_mut)]
19506 let mut request = self
19507 .client
19508 .post(url)
19509 .header(
19510 ::reqwest::header::ACCEPT,
19511 ::reqwest::header::HeaderValue::from_static("application/json"),
19512 )
19513 .json(&body)
19514 .query(&progenitor_client::QueryParam::new("_async", &async_))
19515 .query(&progenitor_client::QueryParam::new("_group", &group))
19516 .query(&progenitor_client::QueryParam::new("fs", &fs))
19517 .query(&progenitor_client::QueryParam::new("opt", &opt))
19518 .query(&progenitor_client::QueryParam::new("remote", &remote))
19519 .headers(header_map)
19520 .build()?;
19521 let info = OperationInfo {
19522 operation_id: "operations_stat",
19523 };
19524 self.pre(&mut request, &info).await?;
19525 let result = self.exec(request, &info).await;
19526 self.post(&result, &info).await?;
19527 let response = result?;
19528 match response.status().as_u16() {
19529 200u16 => ResponseValue::from_response(response).await,
19530 400u16..=499u16 => Err(Error::ErrorResponse(
19531 ResponseValue::from_response(response).await?,
19532 )),
19533 500u16..=599u16 => Err(Error::ErrorResponse(
19534 ResponseValue::from_response(response).await?,
19535 )),
19536 _ => Err(Error::UnexpectedResponse(response)),
19537 }
19538 }
19539
19540 ///Get remote quota
19541 ///
19542 ///Returns storage quota and usage details for the remote, equivalent to
19543 /// `rclone about`.
19544 ///
19545 ///Sends a `POST` request to `/operations/about`
19546 ///
19547 ///Arguments:
19548 /// - `async_`: Run the command asynchronously. Returns a job id
19549 /// immediately.
19550 /// - `group`: Assign the request to a custom stats group.
19551 /// - `fs`: Remote name or path to query for capacity information.
19552 /// - `body`
19553 pub async fn operations_about<'a>(
19554 &'a self,
19555 async_: Option<bool>,
19556 group: Option<&'a str>,
19557 fs: Option<&'a str>,
19558 body: &'a types::OperationsAboutRequest,
19559 ) -> Result<ResponseValue<types::OperationsAboutResponse>, Error<types::RcError>> {
19560 let url = format!("{}/operations/about", self.baseurl,);
19561 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19562 header_map.append(
19563 ::reqwest::header::HeaderName::from_static("api-version"),
19564 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19565 );
19566 #[allow(unused_mut)]
19567 let mut request = self
19568 .client
19569 .post(url)
19570 .header(
19571 ::reqwest::header::ACCEPT,
19572 ::reqwest::header::HeaderValue::from_static("application/json"),
19573 )
19574 .json(&body)
19575 .query(&progenitor_client::QueryParam::new("_async", &async_))
19576 .query(&progenitor_client::QueryParam::new("_group", &group))
19577 .query(&progenitor_client::QueryParam::new("fs", &fs))
19578 .headers(header_map)
19579 .build()?;
19580 let info = OperationInfo {
19581 operation_id: "operations_about",
19582 };
19583 self.pre(&mut request, &info).await?;
19584 let result = self.exec(request, &info).await;
19585 self.post(&result, &info).await?;
19586 let response = result?;
19587 match response.status().as_u16() {
19588 200u16 => ResponseValue::from_response(response).await,
19589 400u16..=499u16 => Err(Error::ErrorResponse(
19590 ResponseValue::from_response(response).await?,
19591 )),
19592 500u16..=599u16 => Err(Error::ErrorResponse(
19593 ResponseValue::from_response(response).await?,
19594 )),
19595 _ => Err(Error::UnexpectedResponse(response)),
19596 }
19597 }
19598
19599 ///Upload files via multipart
19600 ///
19601 ///Accepts multipart/form-data payloads and writes the uploaded files to
19602 /// the specified remote path.
19603 ///
19604 ///Sends a `POST` request to `/operations/uploadfile`
19605 ///
19606 ///Arguments:
19607 /// - `async_`: Run the command asynchronously. Returns a job id
19608 /// immediately.
19609 /// - `group`: Assign the request to a custom stats group.
19610 /// - `fs`: Remote name or path where the uploaded file should be stored.
19611 /// - `remote`: Destination path within `fs` for the uploaded file.
19612 /// - `body`: Multipart form payload containing one or more files to upload.
19613 pub async fn operations_uploadfile<'a, B: Into<reqwest::Body>>(
19614 &'a self,
19615 async_: Option<bool>,
19616 group: Option<&'a str>,
19617 fs: Option<&'a str>,
19618 remote: Option<&'a str>,
19619 body: B,
19620 ) -> Result<ResponseValue<types::OperationsUploadfileResponse>, Error<types::RcError>> {
19621 let url = format!("{}/operations/uploadfile", self.baseurl,);
19622 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19623 header_map.append(
19624 ::reqwest::header::HeaderName::from_static("api-version"),
19625 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19626 );
19627 #[allow(unused_mut)]
19628 let mut request = self
19629 .client
19630 .post(url)
19631 .header(
19632 ::reqwest::header::ACCEPT,
19633 ::reqwest::header::HeaderValue::from_static("application/json"),
19634 )
19635 .header(
19636 ::reqwest::header::CONTENT_TYPE,
19637 ::reqwest::header::HeaderValue::from_static("application/octet-stream"),
19638 )
19639 .body(body)
19640 .query(&progenitor_client::QueryParam::new("_async", &async_))
19641 .query(&progenitor_client::QueryParam::new("_group", &group))
19642 .query(&progenitor_client::QueryParam::new("fs", &fs))
19643 .query(&progenitor_client::QueryParam::new("remote", &remote))
19644 .headers(header_map)
19645 .build()?;
19646 let info = OperationInfo {
19647 operation_id: "operations_uploadfile",
19648 };
19649 self.pre(&mut request, &info).await?;
19650 let result = self.exec(request, &info).await;
19651 self.post(&result, &info).await?;
19652 let response = result?;
19653 match response.status().as_u16() {
19654 200u16 => ResponseValue::from_response(response).await,
19655 400u16..=499u16 => Err(Error::ErrorResponse(
19656 ResponseValue::from_response(response).await?,
19657 )),
19658 500u16..=599u16 => Err(Error::ErrorResponse(
19659 ResponseValue::from_response(response).await?,
19660 )),
19661 _ => Err(Error::UnexpectedResponse(response)),
19662 }
19663 }
19664
19665 ///Purge directory
19666 ///
19667 ///Deletes a directory or container and all of its contents.
19668 ///
19669 ///Sends a `POST` request to `/operations/purge`
19670 ///
19671 ///Arguments:
19672 /// - `async_`: Run the command asynchronously. Returns a job id
19673 /// immediately.
19674 /// - `config`: JSON encoded config overrides applied for this call only.
19675 /// - `filter`: JSON encoded filter overrides applied for this call only.
19676 /// - `group`: Assign the request to a custom stats group.
19677 /// - `fs`: Remote name or path from which to remove all contents.
19678 /// - `remote`: Path within `fs` whose contents should be purged.
19679 /// - `body`
19680 pub async fn operations_purge<'a>(
19681 &'a self,
19682 async_: Option<bool>,
19683 config: Option<&'a str>,
19684 filter: Option<&'a str>,
19685 group: Option<&'a str>,
19686 fs: Option<&'a str>,
19687 remote: Option<&'a str>,
19688 body: &'a types::OperationsPurgeRequest,
19689 ) -> Result<ResponseValue<types::OperationsPurgeResponse>, Error<types::RcError>> {
19690 let url = format!("{}/operations/purge", self.baseurl,);
19691 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19692 header_map.append(
19693 ::reqwest::header::HeaderName::from_static("api-version"),
19694 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19695 );
19696 #[allow(unused_mut)]
19697 let mut request = self
19698 .client
19699 .post(url)
19700 .header(
19701 ::reqwest::header::ACCEPT,
19702 ::reqwest::header::HeaderValue::from_static("application/json"),
19703 )
19704 .json(&body)
19705 .query(&progenitor_client::QueryParam::new("_async", &async_))
19706 .query(&progenitor_client::QueryParam::new("_config", &config))
19707 .query(&progenitor_client::QueryParam::new("_filter", &filter))
19708 .query(&progenitor_client::QueryParam::new("_group", &group))
19709 .query(&progenitor_client::QueryParam::new("fs", &fs))
19710 .query(&progenitor_client::QueryParam::new("remote", &remote))
19711 .headers(header_map)
19712 .build()?;
19713 let info = OperationInfo {
19714 operation_id: "operations_purge",
19715 };
19716 self.pre(&mut request, &info).await?;
19717 let result = self.exec(request, &info).await;
19718 self.post(&result, &info).await?;
19719 let response = result?;
19720 match response.status().as_u16() {
19721 200u16 => ResponseValue::from_response(response).await,
19722 400u16..=499u16 => Err(Error::ErrorResponse(
19723 ResponseValue::from_response(response).await?,
19724 )),
19725 500u16..=599u16 => Err(Error::ErrorResponse(
19726 ResponseValue::from_response(response).await?,
19727 )),
19728 _ => Err(Error::UnexpectedResponse(response)),
19729 }
19730 }
19731
19732 ///Create directory
19733 ///
19734 ///Creates the target directory or container if it does not exist.
19735 ///
19736 ///Sends a `POST` request to `/operations/mkdir`
19737 ///
19738 ///Arguments:
19739 /// - `async_`: Run the command asynchronously. Returns a job id
19740 /// immediately.
19741 /// - `group`: Assign the request to a custom stats group.
19742 /// - `fs`: Remote name or path in which to create a directory.
19743 /// - `remote`: Directory path within `fs` to create.
19744 /// - `body`
19745 pub async fn operations_mkdir<'a>(
19746 &'a self,
19747 async_: Option<bool>,
19748 group: Option<&'a str>,
19749 fs: Option<&'a str>,
19750 remote: Option<&'a str>,
19751 body: &'a types::OperationsMkdirRequest,
19752 ) -> Result<ResponseValue<types::OperationsMkdirResponse>, Error<types::RcError>> {
19753 let url = format!("{}/operations/mkdir", self.baseurl,);
19754 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19755 header_map.append(
19756 ::reqwest::header::HeaderName::from_static("api-version"),
19757 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19758 );
19759 #[allow(unused_mut)]
19760 let mut request = self
19761 .client
19762 .post(url)
19763 .header(
19764 ::reqwest::header::ACCEPT,
19765 ::reqwest::header::HeaderValue::from_static("application/json"),
19766 )
19767 .json(&body)
19768 .query(&progenitor_client::QueryParam::new("_async", &async_))
19769 .query(&progenitor_client::QueryParam::new("_group", &group))
19770 .query(&progenitor_client::QueryParam::new("fs", &fs))
19771 .query(&progenitor_client::QueryParam::new("remote", &remote))
19772 .headers(header_map)
19773 .build()?;
19774 let info = OperationInfo {
19775 operation_id: "operations_mkdir",
19776 };
19777 self.pre(&mut request, &info).await?;
19778 let result = self.exec(request, &info).await;
19779 self.post(&result, &info).await?;
19780 let response = result?;
19781 match response.status().as_u16() {
19782 200u16 => ResponseValue::from_response(response).await,
19783 400u16..=499u16 => Err(Error::ErrorResponse(
19784 ResponseValue::from_response(response).await?,
19785 )),
19786 500u16..=599u16 => Err(Error::ErrorResponse(
19787 ResponseValue::from_response(response).await?,
19788 )),
19789 _ => Err(Error::UnexpectedResponse(response)),
19790 }
19791 }
19792
19793 ///Remove empty directory
19794 ///
19795 ///Deletes an empty directory or container.
19796 ///
19797 ///Sends a `POST` request to `/operations/rmdir`
19798 ///
19799 ///Arguments:
19800 /// - `async_`: Run the command asynchronously. Returns a job id
19801 /// immediately.
19802 /// - `group`: Assign the request to a custom stats group.
19803 /// - `fs`: Remote name or path containing the directory to remove.
19804 /// - `remote`: Directory path within `fs` to delete.
19805 /// - `body`
19806 pub async fn operations_rmdir<'a>(
19807 &'a self,
19808 async_: Option<bool>,
19809 group: Option<&'a str>,
19810 fs: Option<&'a str>,
19811 remote: Option<&'a str>,
19812 body: &'a types::OperationsRmdirRequest,
19813 ) -> Result<ResponseValue<types::OperationsRmdirResponse>, Error<types::RcError>> {
19814 let url = format!("{}/operations/rmdir", self.baseurl,);
19815 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19816 header_map.append(
19817 ::reqwest::header::HeaderName::from_static("api-version"),
19818 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19819 );
19820 #[allow(unused_mut)]
19821 let mut request = self
19822 .client
19823 .post(url)
19824 .header(
19825 ::reqwest::header::ACCEPT,
19826 ::reqwest::header::HeaderValue::from_static("application/json"),
19827 )
19828 .json(&body)
19829 .query(&progenitor_client::QueryParam::new("_async", &async_))
19830 .query(&progenitor_client::QueryParam::new("_group", &group))
19831 .query(&progenitor_client::QueryParam::new("fs", &fs))
19832 .query(&progenitor_client::QueryParam::new("remote", &remote))
19833 .headers(header_map)
19834 .build()?;
19835 let info = OperationInfo {
19836 operation_id: "operations_rmdir",
19837 };
19838 self.pre(&mut request, &info).await?;
19839 let result = self.exec(request, &info).await;
19840 self.post(&result, &info).await?;
19841 let response = result?;
19842 match response.status().as_u16() {
19843 200u16 => ResponseValue::from_response(response).await,
19844 400u16..=499u16 => Err(Error::ErrorResponse(
19845 ResponseValue::from_response(response).await?,
19846 )),
19847 500u16..=599u16 => Err(Error::ErrorResponse(
19848 ResponseValue::from_response(response).await?,
19849 )),
19850 _ => Err(Error::UnexpectedResponse(response)),
19851 }
19852 }
19853
19854 ///Compare source and destination
19855 ///
19856 ///Compares source and destination trees, reporting matches, differences,
19857 /// and missing files.
19858 ///
19859 ///Sends a `POST` request to `/operations/check`
19860 ///
19861 ///Arguments:
19862 /// - `async_`: Run the command asynchronously. Returns a job id
19863 /// immediately.
19864 /// - `group`: Assign the request to a custom stats group.
19865 /// - `check_file_fs`: Remote containing the checksum SUM file when using
19866 /// `checkFileHash`.
19867 /// - `check_file_hash`: Hash name to expect in the supplied SUM file, such
19868 /// as `md5`.
19869 /// - `check_file_remote`: Path within `checkFileFs` to the checksum SUM
19870 /// file.
19871 /// - `combined`: Set to true to include a combined summary report in the
19872 /// response.
19873 /// - `differ`: Set to true to include differing files in the report.
19874 /// - `download`: Set to true to read file contents during comparison
19875 /// instead of relying on hashes.
19876 /// - `dst_fs`: Destination remote name or path that should match the
19877 /// source.
19878 /// - `error`: Set to true to include entries that encountered errors.
19879 /// - `match_`: Set to true to include matching files in the report.
19880 /// - `missing_on_dst`: Set to true to report files missing from the
19881 /// destination.
19882 /// - `missing_on_src`: Set to true to report files missing from the source.
19883 /// - `one_way`: Set to true to only ensure that source files exist on the
19884 /// destination.
19885 /// - `src_fs`: Source remote name or path to verify, e.g. `drive:`.
19886 /// - `body`
19887 pub async fn operations_check<'a>(
19888 &'a self,
19889 async_: Option<bool>,
19890 group: Option<&'a str>,
19891 check_file_fs: Option<&'a str>,
19892 check_file_hash: Option<&'a str>,
19893 check_file_remote: Option<&'a str>,
19894 combined: Option<bool>,
19895 differ: Option<bool>,
19896 download: Option<bool>,
19897 dst_fs: Option<&'a str>,
19898 error: Option<bool>,
19899 match_: Option<bool>,
19900 missing_on_dst: Option<bool>,
19901 missing_on_src: Option<bool>,
19902 one_way: Option<bool>,
19903 src_fs: Option<&'a str>,
19904 body: &'a types::OperationsCheckRequest,
19905 ) -> Result<ResponseValue<types::OperationsCheckResponse>, Error<types::RcError>> {
19906 let url = format!("{}/operations/check", self.baseurl,);
19907 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
19908 header_map.append(
19909 ::reqwest::header::HeaderName::from_static("api-version"),
19910 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
19911 );
19912 #[allow(unused_mut)]
19913 let mut request = self
19914 .client
19915 .post(url)
19916 .header(
19917 ::reqwest::header::ACCEPT,
19918 ::reqwest::header::HeaderValue::from_static("application/json"),
19919 )
19920 .json(&body)
19921 .query(&progenitor_client::QueryParam::new("_async", &async_))
19922 .query(&progenitor_client::QueryParam::new("_group", &group))
19923 .query(&progenitor_client::QueryParam::new(
19924 "checkFileFs",
19925 &check_file_fs,
19926 ))
19927 .query(&progenitor_client::QueryParam::new(
19928 "checkFileHash",
19929 &check_file_hash,
19930 ))
19931 .query(&progenitor_client::QueryParam::new(
19932 "checkFileRemote",
19933 &check_file_remote,
19934 ))
19935 .query(&progenitor_client::QueryParam::new("combined", &combined))
19936 .query(&progenitor_client::QueryParam::new("differ", &differ))
19937 .query(&progenitor_client::QueryParam::new("download", &download))
19938 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
19939 .query(&progenitor_client::QueryParam::new("error", &error))
19940 .query(&progenitor_client::QueryParam::new("match", &match_))
19941 .query(&progenitor_client::QueryParam::new(
19942 "missingOnDst",
19943 &missing_on_dst,
19944 ))
19945 .query(&progenitor_client::QueryParam::new(
19946 "missingOnSrc",
19947 &missing_on_src,
19948 ))
19949 .query(&progenitor_client::QueryParam::new("oneWay", &one_way))
19950 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
19951 .headers(header_map)
19952 .build()?;
19953 let info = OperationInfo {
19954 operation_id: "operations_check",
19955 };
19956 self.pre(&mut request, &info).await?;
19957 let result = self.exec(request, &info).await;
19958 self.post(&result, &info).await?;
19959 let response = result?;
19960 match response.status().as_u16() {
19961 200u16 => ResponseValue::from_response(response).await,
19962 400u16..=499u16 => Err(Error::ErrorResponse(
19963 ResponseValue::from_response(response).await?,
19964 )),
19965 500u16..=599u16 => Err(Error::ErrorResponse(
19966 ResponseValue::from_response(response).await?,
19967 )),
19968 _ => Err(Error::UnexpectedResponse(response)),
19969 }
19970 }
19971
19972 ///Sync source to destination
19973 ///
19974 ///Synchronises a source remote to a destination remote, making the
19975 /// destination match the source.
19976 ///
19977 ///Sends a `POST` request to `/sync/sync`
19978 ///
19979 ///Arguments:
19980 /// - `async_`: Run the command asynchronously. Returns a job id
19981 /// immediately.
19982 /// - `config`: JSON encoded config overrides applied for this call only.
19983 /// - `filter`: JSON encoded filter overrides applied for this call only.
19984 /// - `group`: Assign the request to a custom stats group.
19985 /// - `create_empty_src_dirs`: Set to true to create empty source
19986 /// directories on the destination.
19987 /// - `dst_fs`: Destination remote path to sync to, e.g. `drive:dst`.
19988 /// - `src_fs`: Source remote path to sync from, e.g. `drive:src`.
19989 /// - `body`
19990 pub async fn sync_sync<'a>(
19991 &'a self,
19992 async_: Option<bool>,
19993 config: Option<&'a str>,
19994 filter: Option<&'a str>,
19995 group: Option<&'a str>,
19996 create_empty_src_dirs: Option<bool>,
19997 dst_fs: Option<&'a str>,
19998 src_fs: Option<&'a str>,
19999 body: &'a types::SyncSyncRequest,
20000 ) -> Result<ResponseValue<types::SyncSyncResponse>, Error<types::RcError>> {
20001 let url = format!("{}/sync/sync", self.baseurl,);
20002 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20003 header_map.append(
20004 ::reqwest::header::HeaderName::from_static("api-version"),
20005 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20006 );
20007 #[allow(unused_mut)]
20008 let mut request = self
20009 .client
20010 .post(url)
20011 .header(
20012 ::reqwest::header::ACCEPT,
20013 ::reqwest::header::HeaderValue::from_static("application/json"),
20014 )
20015 .json(&body)
20016 .query(&progenitor_client::QueryParam::new("_async", &async_))
20017 .query(&progenitor_client::QueryParam::new("_config", &config))
20018 .query(&progenitor_client::QueryParam::new("_filter", &filter))
20019 .query(&progenitor_client::QueryParam::new("_group", &group))
20020 .query(&progenitor_client::QueryParam::new(
20021 "createEmptySrcDirs",
20022 &create_empty_src_dirs,
20023 ))
20024 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
20025 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
20026 .headers(header_map)
20027 .build()?;
20028 let info = OperationInfo {
20029 operation_id: "sync_sync",
20030 };
20031 self.pre(&mut request, &info).await?;
20032 let result = self.exec(request, &info).await;
20033 self.post(&result, &info).await?;
20034 let response = result?;
20035 match response.status().as_u16() {
20036 200u16 => ResponseValue::from_response(response).await,
20037 400u16..=499u16 => Err(Error::ErrorResponse(
20038 ResponseValue::from_response(response).await?,
20039 )),
20040 500u16..=599u16 => Err(Error::ErrorResponse(
20041 ResponseValue::from_response(response).await?,
20042 )),
20043 _ => Err(Error::UnexpectedResponse(response)),
20044 }
20045 }
20046
20047 ///Copy source to destination
20048 ///
20049 ///Copies objects from a source remote to a destination remote without
20050 /// deleting destination files.
20051 ///
20052 ///Sends a `POST` request to `/sync/copy`
20053 ///
20054 ///Arguments:
20055 /// - `async_`: Run the command asynchronously. Returns a job id
20056 /// immediately.
20057 /// - `config`: JSON encoded config overrides applied for this call only.
20058 /// - `filter`: JSON encoded filter overrides applied for this call only.
20059 /// - `group`: Assign the request to a custom stats group.
20060 /// - `create_empty_src_dirs`: Set to true to replicate empty source
20061 /// directories on the destination.
20062 /// - `dst_fs`: Destination remote path to copy to.
20063 /// - `src_fs`: Source remote path to copy from.
20064 /// - `body`
20065 pub async fn sync_copy<'a>(
20066 &'a self,
20067 async_: Option<bool>,
20068 config: Option<&'a str>,
20069 filter: Option<&'a str>,
20070 group: Option<&'a str>,
20071 create_empty_src_dirs: Option<bool>,
20072 dst_fs: Option<&'a str>,
20073 src_fs: Option<&'a str>,
20074 body: &'a types::SyncCopyRequest,
20075 ) -> Result<ResponseValue<types::SyncCopyResponse>, Error<types::RcError>> {
20076 let url = format!("{}/sync/copy", self.baseurl,);
20077 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20078 header_map.append(
20079 ::reqwest::header::HeaderName::from_static("api-version"),
20080 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20081 );
20082 #[allow(unused_mut)]
20083 let mut request = self
20084 .client
20085 .post(url)
20086 .header(
20087 ::reqwest::header::ACCEPT,
20088 ::reqwest::header::HeaderValue::from_static("application/json"),
20089 )
20090 .json(&body)
20091 .query(&progenitor_client::QueryParam::new("_async", &async_))
20092 .query(&progenitor_client::QueryParam::new("_config", &config))
20093 .query(&progenitor_client::QueryParam::new("_filter", &filter))
20094 .query(&progenitor_client::QueryParam::new("_group", &group))
20095 .query(&progenitor_client::QueryParam::new(
20096 "createEmptySrcDirs",
20097 &create_empty_src_dirs,
20098 ))
20099 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
20100 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
20101 .headers(header_map)
20102 .build()?;
20103 let info = OperationInfo {
20104 operation_id: "sync_copy",
20105 };
20106 self.pre(&mut request, &info).await?;
20107 let result = self.exec(request, &info).await;
20108 self.post(&result, &info).await?;
20109 let response = result?;
20110 match response.status().as_u16() {
20111 200u16 => ResponseValue::from_response(response).await,
20112 400u16..=499u16 => Err(Error::ErrorResponse(
20113 ResponseValue::from_response(response).await?,
20114 )),
20115 500u16..=599u16 => Err(Error::ErrorResponse(
20116 ResponseValue::from_response(response).await?,
20117 )),
20118 _ => Err(Error::UnexpectedResponse(response)),
20119 }
20120 }
20121
20122 ///Move source to destination
20123 ///
20124 ///Moves objects from a source remote to a destination remote, optionally
20125 /// cleaning up empty directories.
20126 ///
20127 ///Sends a `POST` request to `/sync/move`
20128 ///
20129 ///Arguments:
20130 /// - `async_`: Run the command asynchronously. Returns a job id
20131 /// immediately.
20132 /// - `config`: JSON encoded config overrides applied for this call only.
20133 /// - `filter`: JSON encoded filter overrides applied for this call only.
20134 /// - `group`: Assign the request to a custom stats group.
20135 /// - `create_empty_src_dirs`: Set to true to create empty source
20136 /// directories on the destination.
20137 /// - `delete_empty_src_dirs`: Set to true to delete empty directories from
20138 /// the source after the move completes.
20139 /// - `dst_fs`: Destination remote path that will receive moved files.
20140 /// - `src_fs`: Source remote path whose contents will be moved.
20141 /// - `body`
20142 pub async fn sync_move<'a>(
20143 &'a self,
20144 async_: Option<bool>,
20145 config: Option<&'a str>,
20146 filter: Option<&'a str>,
20147 group: Option<&'a str>,
20148 create_empty_src_dirs: Option<bool>,
20149 delete_empty_src_dirs: Option<bool>,
20150 dst_fs: Option<&'a str>,
20151 src_fs: Option<&'a str>,
20152 body: &'a types::SyncMoveRequest,
20153 ) -> Result<ResponseValue<types::SyncMoveResponse>, Error<types::RcError>> {
20154 let url = format!("{}/sync/move", self.baseurl,);
20155 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20156 header_map.append(
20157 ::reqwest::header::HeaderName::from_static("api-version"),
20158 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20159 );
20160 #[allow(unused_mut)]
20161 let mut request = self
20162 .client
20163 .post(url)
20164 .header(
20165 ::reqwest::header::ACCEPT,
20166 ::reqwest::header::HeaderValue::from_static("application/json"),
20167 )
20168 .json(&body)
20169 .query(&progenitor_client::QueryParam::new("_async", &async_))
20170 .query(&progenitor_client::QueryParam::new("_config", &config))
20171 .query(&progenitor_client::QueryParam::new("_filter", &filter))
20172 .query(&progenitor_client::QueryParam::new("_group", &group))
20173 .query(&progenitor_client::QueryParam::new(
20174 "createEmptySrcDirs",
20175 &create_empty_src_dirs,
20176 ))
20177 .query(&progenitor_client::QueryParam::new(
20178 "deleteEmptySrcDirs",
20179 &delete_empty_src_dirs,
20180 ))
20181 .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
20182 .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
20183 .headers(header_map)
20184 .build()?;
20185 let info = OperationInfo {
20186 operation_id: "sync_move",
20187 };
20188 self.pre(&mut request, &info).await?;
20189 let result = self.exec(request, &info).await;
20190 self.post(&result, &info).await?;
20191 let response = result?;
20192 match response.status().as_u16() {
20193 200u16 => ResponseValue::from_response(response).await,
20194 400u16..=499u16 => Err(Error::ErrorResponse(
20195 ResponseValue::from_response(response).await?,
20196 )),
20197 500u16..=599u16 => Err(Error::ErrorResponse(
20198 ResponseValue::from_response(response).await?,
20199 )),
20200 _ => Err(Error::UnexpectedResponse(response)),
20201 }
20202 }
20203
20204 ///Bidirectional sync
20205 ///
20206 ///Performs a bidirectional synchronisation between two paths, supporting
20207 /// safety checks and recovery options.
20208 ///
20209 ///Sends a `POST` request to `/sync/bisync`
20210 ///
20211 ///Arguments:
20212 /// - `async_`: Run the command asynchronously. Returns a job id
20213 /// immediately.
20214 /// - `config`: JSON encoded config overrides applied for this call only.
20215 /// - `filter`: JSON encoded filter overrides applied for this call only.
20216 /// - `group`: Assign the request to a custom stats group.
20217 /// - `backupdir1`: Backup directory on the first remote for changed files.
20218 /// - `backupdir2`: Backup directory on the second remote for changed files.
20219 /// - `check_access`: Set to true to abort if `RCLONE_TEST` files are
20220 /// missing on either side.
20221 /// - `check_filename`: Override the access-check sentinel filename;
20222 /// defaults to `RCLONE_TEST`.
20223 /// - `check_sync`: Controls final listing comparison; leave true for normal
20224 /// verification or set false to skip.
20225 /// - `create_empty_src_dirs`: Set to true to mirror empty directories
20226 /// between the two paths.
20227 /// - `dry_run`: Set to true to simulate the bisync run without making
20228 /// changes.
20229 /// - `filters_file`: Path to an rclone filters file applied to both paths.
20230 /// - `force`: Set to true to bypass the `maxDelete` safety check.
20231 /// - `ignore_listing_checksum`: Set to true to ignore checksum differences
20232 /// when comparing listings.
20233 /// - `max_delete`: Abort the run if deletions exceed this percentage
20234 /// (default 50).
20235 /// - `no_cleanup`: Set to true to keep bisync working files after
20236 /// completion.
20237 /// - `path1`: First remote directory, e.g. `drive:path1`.
20238 /// - `path2`: Second remote directory, e.g. `drive:path2`.
20239 /// - `remove_empty_dirs`: Set to true to remove empty directories during
20240 /// cleanup.
20241 /// - `resilient`: Set to true to allow retrying after certain recoverable
20242 /// errors.
20243 /// - `resync`: Set to true to perform a one-time resync, rebuilding bisync
20244 /// history.
20245 /// - `workdir`: Directory path used to store bisync working files.
20246 /// - `body`
20247 pub async fn sync_bisync<'a>(
20248 &'a self,
20249 async_: Option<bool>,
20250 config: Option<&'a str>,
20251 filter: Option<&'a str>,
20252 group: Option<&'a str>,
20253 backupdir1: Option<&'a str>,
20254 backupdir2: Option<&'a str>,
20255 check_access: Option<bool>,
20256 check_filename: Option<&'a str>,
20257 check_sync: Option<bool>,
20258 create_empty_src_dirs: Option<bool>,
20259 dry_run: Option<bool>,
20260 filters_file: Option<&'a str>,
20261 force: Option<bool>,
20262 ignore_listing_checksum: Option<bool>,
20263 max_delete: Option<f64>,
20264 no_cleanup: Option<bool>,
20265 path1: Option<&'a str>,
20266 path2: Option<&'a str>,
20267 remove_empty_dirs: Option<bool>,
20268 resilient: Option<bool>,
20269 resync: Option<bool>,
20270 workdir: Option<&'a str>,
20271 body: &'a types::SyncBisyncRequest,
20272 ) -> Result<ResponseValue<types::SyncBisyncResponse>, Error<types::RcError>> {
20273 let url = format!("{}/sync/bisync", self.baseurl,);
20274 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20275 header_map.append(
20276 ::reqwest::header::HeaderName::from_static("api-version"),
20277 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20278 );
20279 #[allow(unused_mut)]
20280 let mut request = self
20281 .client
20282 .post(url)
20283 .header(
20284 ::reqwest::header::ACCEPT,
20285 ::reqwest::header::HeaderValue::from_static("application/json"),
20286 )
20287 .json(&body)
20288 .query(&progenitor_client::QueryParam::new("_async", &async_))
20289 .query(&progenitor_client::QueryParam::new("_config", &config))
20290 .query(&progenitor_client::QueryParam::new("_filter", &filter))
20291 .query(&progenitor_client::QueryParam::new("_group", &group))
20292 .query(&progenitor_client::QueryParam::new(
20293 "backupdir1",
20294 &backupdir1,
20295 ))
20296 .query(&progenitor_client::QueryParam::new(
20297 "backupdir2",
20298 &backupdir2,
20299 ))
20300 .query(&progenitor_client::QueryParam::new(
20301 "checkAccess",
20302 &check_access,
20303 ))
20304 .query(&progenitor_client::QueryParam::new(
20305 "checkFilename",
20306 &check_filename,
20307 ))
20308 .query(&progenitor_client::QueryParam::new(
20309 "checkSync",
20310 &check_sync,
20311 ))
20312 .query(&progenitor_client::QueryParam::new(
20313 "createEmptySrcDirs",
20314 &create_empty_src_dirs,
20315 ))
20316 .query(&progenitor_client::QueryParam::new("dryRun", &dry_run))
20317 .query(&progenitor_client::QueryParam::new(
20318 "filtersFile",
20319 &filters_file,
20320 ))
20321 .query(&progenitor_client::QueryParam::new("force", &force))
20322 .query(&progenitor_client::QueryParam::new(
20323 "ignoreListingChecksum",
20324 &ignore_listing_checksum,
20325 ))
20326 .query(&progenitor_client::QueryParam::new(
20327 "maxDelete",
20328 &max_delete,
20329 ))
20330 .query(&progenitor_client::QueryParam::new(
20331 "noCleanup",
20332 &no_cleanup,
20333 ))
20334 .query(&progenitor_client::QueryParam::new("path1", &path1))
20335 .query(&progenitor_client::QueryParam::new("path2", &path2))
20336 .query(&progenitor_client::QueryParam::new(
20337 "removeEmptyDirs",
20338 &remove_empty_dirs,
20339 ))
20340 .query(&progenitor_client::QueryParam::new("resilient", &resilient))
20341 .query(&progenitor_client::QueryParam::new("resync", &resync))
20342 .query(&progenitor_client::QueryParam::new("workdir", &workdir))
20343 .headers(header_map)
20344 .build()?;
20345 let info = OperationInfo {
20346 operation_id: "sync_bisync",
20347 };
20348 self.pre(&mut request, &info).await?;
20349 let result = self.exec(request, &info).await;
20350 self.post(&result, &info).await?;
20351 let response = result?;
20352 match response.status().as_u16() {
20353 200u16 => ResponseValue::from_response(response).await,
20354 400u16..=499u16 => Err(Error::ErrorResponse(
20355 ResponseValue::from_response(response).await?,
20356 )),
20357 500u16..=599u16 => Err(Error::ErrorResponse(
20358 ResponseValue::from_response(response).await?,
20359 )),
20360 _ => Err(Error::UnexpectedResponse(response)),
20361 }
20362 }
20363
20364 ///List option blocks
20365 ///
20366 ///Returns the names of option blocks that can be queried or updated.
20367 ///
20368 ///Sends a `POST` request to `/options/blocks`
20369 ///
20370 ///Arguments:
20371 /// - `async_`: Run the command asynchronously. Returns a job id
20372 /// immediately.
20373 /// - `group`: Assign the request to a custom stats group.
20374 /// - `body`
20375 pub async fn options_blocks<'a>(
20376 &'a self,
20377 async_: Option<bool>,
20378 group: Option<&'a str>,
20379 body: &'a types::OptionsBlocksRequest,
20380 ) -> Result<ResponseValue<types::OptionsBlocksResponse>, Error<types::RcError>> {
20381 let url = format!("{}/options/blocks", self.baseurl,);
20382 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20383 header_map.append(
20384 ::reqwest::header::HeaderName::from_static("api-version"),
20385 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20386 );
20387 #[allow(unused_mut)]
20388 let mut request = self
20389 .client
20390 .post(url)
20391 .header(
20392 ::reqwest::header::ACCEPT,
20393 ::reqwest::header::HeaderValue::from_static("application/json"),
20394 )
20395 .json(&body)
20396 .query(&progenitor_client::QueryParam::new("_async", &async_))
20397 .query(&progenitor_client::QueryParam::new("_group", &group))
20398 .headers(header_map)
20399 .build()?;
20400 let info = OperationInfo {
20401 operation_id: "options_blocks",
20402 };
20403 self.pre(&mut request, &info).await?;
20404 let result = self.exec(request, &info).await;
20405 self.post(&result, &info).await?;
20406 let response = result?;
20407 match response.status().as_u16() {
20408 200u16 => ResponseValue::from_response(response).await,
20409 400u16..=499u16 => Err(Error::ErrorResponse(
20410 ResponseValue::from_response(response).await?,
20411 )),
20412 500u16..=599u16 => Err(Error::ErrorResponse(
20413 ResponseValue::from_response(response).await?,
20414 )),
20415 _ => Err(Error::UnexpectedResponse(response)),
20416 }
20417 }
20418
20419 ///Get option values
20420 ///
20421 ///Returns the current global option values, optionally filtered by block.
20422 ///
20423 ///Sends a `POST` request to `/options/get`
20424 ///
20425 ///Arguments:
20426 /// - `async_`: Run the command asynchronously. Returns a job id
20427 /// immediately.
20428 /// - `group`: Assign the request to a custom stats group.
20429 /// - `blocks`: Optional comma-separated list of option block names to
20430 /// return.
20431 /// - `body`
20432 pub async fn options_get<'a>(
20433 &'a self,
20434 async_: Option<bool>,
20435 group: Option<&'a str>,
20436 blocks: Option<&'a str>,
20437 body: &'a types::OptionsGetRequest,
20438 ) -> Result<ResponseValue<types::OptionsGetResponse>, Error<types::RcError>> {
20439 let url = format!("{}/options/get", self.baseurl,);
20440 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20441 header_map.append(
20442 ::reqwest::header::HeaderName::from_static("api-version"),
20443 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20444 );
20445 #[allow(unused_mut)]
20446 let mut request = self
20447 .client
20448 .post(url)
20449 .header(
20450 ::reqwest::header::ACCEPT,
20451 ::reqwest::header::HeaderValue::from_static("application/json"),
20452 )
20453 .json(&body)
20454 .query(&progenitor_client::QueryParam::new("_async", &async_))
20455 .query(&progenitor_client::QueryParam::new("_group", &group))
20456 .query(&progenitor_client::QueryParam::new("blocks", &blocks))
20457 .headers(header_map)
20458 .build()?;
20459 let info = OperationInfo {
20460 operation_id: "options_get",
20461 };
20462 self.pre(&mut request, &info).await?;
20463 let result = self.exec(request, &info).await;
20464 self.post(&result, &info).await?;
20465 let response = result?;
20466 match response.status().as_u16() {
20467 200u16 => ResponseValue::from_response(response).await,
20468 400u16..=499u16 => Err(Error::ErrorResponse(
20469 ResponseValue::from_response(response).await?,
20470 )),
20471 500u16..=599u16 => Err(Error::ErrorResponse(
20472 ResponseValue::from_response(response).await?,
20473 )),
20474 _ => Err(Error::UnexpectedResponse(response)),
20475 }
20476 }
20477
20478 ///Describe options
20479 ///
20480 ///Returns metadata for options, including help text and defaults, grouped
20481 /// by block.
20482 ///
20483 ///Sends a `POST` request to `/options/info`
20484 ///
20485 ///Arguments:
20486 /// - `async_`: Run the command asynchronously. Returns a job id
20487 /// immediately.
20488 /// - `group`: Assign the request to a custom stats group.
20489 /// - `blocks`: Optional comma-separated list of option block names to
20490 /// describe.
20491 /// - `body`
20492 pub async fn options_info<'a>(
20493 &'a self,
20494 async_: Option<bool>,
20495 group: Option<&'a str>,
20496 blocks: Option<&'a str>,
20497 body: &'a types::OptionsInfoRequest,
20498 ) -> Result<ResponseValue<types::OptionsInfoResponse>, Error<types::RcError>> {
20499 let url = format!("{}/options/info", self.baseurl,);
20500 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20501 header_map.append(
20502 ::reqwest::header::HeaderName::from_static("api-version"),
20503 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20504 );
20505 #[allow(unused_mut)]
20506 let mut request = self
20507 .client
20508 .post(url)
20509 .header(
20510 ::reqwest::header::ACCEPT,
20511 ::reqwest::header::HeaderValue::from_static("application/json"),
20512 )
20513 .json(&body)
20514 .query(&progenitor_client::QueryParam::new("_async", &async_))
20515 .query(&progenitor_client::QueryParam::new("_group", &group))
20516 .query(&progenitor_client::QueryParam::new("blocks", &blocks))
20517 .headers(header_map)
20518 .build()?;
20519 let info = OperationInfo {
20520 operation_id: "options_info",
20521 };
20522 self.pre(&mut request, &info).await?;
20523 let result = self.exec(request, &info).await;
20524 self.post(&result, &info).await?;
20525 let response = result?;
20526 match response.status().as_u16() {
20527 200u16 => ResponseValue::from_response(response).await,
20528 400u16..=499u16 => Err(Error::ErrorResponse(
20529 ResponseValue::from_response(response).await?,
20530 )),
20531 500u16..=599u16 => Err(Error::ErrorResponse(
20532 ResponseValue::from_response(response).await?,
20533 )),
20534 _ => Err(Error::UnexpectedResponse(response)),
20535 }
20536 }
20537
20538 ///Set option values
20539 ///
20540 ///Sets temporary option overrides for the running process by supplying
20541 /// key/value pairs grouped under option block names. Provide one or more
20542 /// query parameters whose names match the blocks you want to modify (for
20543 /// example `main`, `rc`, `http`). Each block parameter carries an object of
20544 /// option overrides.
20545 ///
20546 ///
20547 ///Sends a `POST` request to `/options/set`
20548 ///
20549 ///Arguments:
20550 /// - `async_`: Run the command asynchronously. Returns a job id
20551 /// immediately.
20552 /// - `group`: Assign the request to a custom stats group.
20553 /// - `dlna`: Overrides for the `dlna` option block.
20554 /// - `filter`: Overrides for the `filter` option block.
20555 /// - `ftp`: Overrides for the `ftp` option block.
20556 /// - `http`: Overrides for the `http` option block.
20557 /// - `log`: Overrides for the `log` option block.
20558 /// - `main`: Overrides for the `main` option block.
20559 /// - `mount`: Overrides for the `mount` option block.
20560 /// - `nfs`: Overrides for the `nfs` option block.
20561 /// - `proxy`: Overrides for the `proxy` option block.
20562 /// - `rc`: Overrides for the `rc` option block.
20563 /// - `restic`: Overrides for the `restic` option block.
20564 /// - `s3`: Overrides for the `s3` option block.
20565 /// - `sftp`: Overrides for the `sftp` option block.
20566 /// - `vfs`: Overrides for the `vfs` option block.
20567 /// - `webdav`: Overrides for the `webdav` option block.
20568 /// - `body`
20569 pub async fn options_set<'a>(
20570 &'a self,
20571 async_: Option<bool>,
20572 group: Option<&'a str>,
20573 dlna: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20574 filter: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20575 ftp: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20576 http: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20577 log: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20578 main: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20579 mount: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20580 nfs: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20581 proxy: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20582 rc: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20583 restic: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20584 s3: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20585 sftp: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20586 vfs: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20587 webdav: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20588 body: &'a types::OptionsSetRequest,
20589 ) -> Result<ResponseValue<types::OptionsSetResponse>, Error<types::RcError>> {
20590 let url = format!("{}/options/set", self.baseurl,);
20591 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20592 header_map.append(
20593 ::reqwest::header::HeaderName::from_static("api-version"),
20594 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20595 );
20596 #[allow(unused_mut)]
20597 let mut request = self
20598 .client
20599 .post(url)
20600 .header(
20601 ::reqwest::header::ACCEPT,
20602 ::reqwest::header::HeaderValue::from_static("application/json"),
20603 )
20604 .json(&body)
20605 .query(&progenitor_client::QueryParam::new("_async", &async_))
20606 .query(&progenitor_client::QueryParam::new("_group", &group))
20607 .query(&progenitor_client::QueryParam::new("dlna", &dlna))
20608 .query(&progenitor_client::QueryParam::new("filter", &filter))
20609 .query(&progenitor_client::QueryParam::new("ftp", &ftp))
20610 .query(&progenitor_client::QueryParam::new("http", &http))
20611 .query(&progenitor_client::QueryParam::new("log", &log))
20612 .query(&progenitor_client::QueryParam::new("main", &main))
20613 .query(&progenitor_client::QueryParam::new("mount", &mount))
20614 .query(&progenitor_client::QueryParam::new("nfs", &nfs))
20615 .query(&progenitor_client::QueryParam::new("proxy", &proxy))
20616 .query(&progenitor_client::QueryParam::new("rc", &rc))
20617 .query(&progenitor_client::QueryParam::new("restic", &restic))
20618 .query(&progenitor_client::QueryParam::new("s3", &s3))
20619 .query(&progenitor_client::QueryParam::new("sftp", &sftp))
20620 .query(&progenitor_client::QueryParam::new("vfs", &vfs))
20621 .query(&progenitor_client::QueryParam::new("webdav", &webdav))
20622 .headers(header_map)
20623 .build()?;
20624 let info = OperationInfo {
20625 operation_id: "options_set",
20626 };
20627 self.pre(&mut request, &info).await?;
20628 let result = self.exec(request, &info).await;
20629 self.post(&result, &info).await?;
20630 let response = result?;
20631 match response.status().as_u16() {
20632 200u16 => ResponseValue::from_response(response).await,
20633 400u16..=499u16 => Err(Error::ErrorResponse(
20634 ResponseValue::from_response(response).await?,
20635 )),
20636 500u16..=599u16 => Err(Error::ErrorResponse(
20637 ResponseValue::from_response(response).await?,
20638 )),
20639 _ => Err(Error::UnexpectedResponse(response)),
20640 }
20641 }
20642
20643 ///Show effective options
20644 ///
20645 ///Returns the current effective options for this request, including
20646 /// `_config` and `_filter` overrides.
20647 ///
20648 ///Sends a `POST` request to `/options/local`
20649 ///
20650 ///Arguments:
20651 /// - `async_`: Run the command asynchronously. Returns a job id
20652 /// immediately.
20653 /// - `group`: Assign the request to a custom stats group.
20654 /// - `body`
20655 pub async fn options_local<'a>(
20656 &'a self,
20657 async_: Option<bool>,
20658 group: Option<&'a str>,
20659 body: &'a types::OptionsLocalRequest,
20660 ) -> Result<ResponseValue<types::OptionsLocalResponse>, Error<types::RcError>> {
20661 let url = format!("{}/options/local", self.baseurl,);
20662 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20663 header_map.append(
20664 ::reqwest::header::HeaderName::from_static("api-version"),
20665 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20666 );
20667 #[allow(unused_mut)]
20668 let mut request = self
20669 .client
20670 .post(url)
20671 .header(
20672 ::reqwest::header::ACCEPT,
20673 ::reqwest::header::HeaderValue::from_static("application/json"),
20674 )
20675 .json(&body)
20676 .query(&progenitor_client::QueryParam::new("_async", &async_))
20677 .query(&progenitor_client::QueryParam::new("_group", &group))
20678 .headers(header_map)
20679 .build()?;
20680 let info = OperationInfo {
20681 operation_id: "options_local",
20682 };
20683 self.pre(&mut request, &info).await?;
20684 let result = self.exec(request, &info).await;
20685 self.post(&result, &info).await?;
20686 let response = result?;
20687 match response.status().as_u16() {
20688 200u16 => ResponseValue::from_response(response).await,
20689 400u16..=499u16 => Err(Error::ErrorResponse(
20690 ResponseValue::from_response(response).await?,
20691 )),
20692 500u16..=599u16 => Err(Error::ErrorResponse(
20693 ResponseValue::from_response(response).await?,
20694 )),
20695 _ => Err(Error::UnexpectedResponse(response)),
20696 }
20697 }
20698
20699 ///List serve instances
20700 ///
20701 ///Returns all running `rclone serve` instances with their IDs and options.
20702 ///
20703 ///Sends a `POST` request to `/serve/list`
20704 ///
20705 ///Arguments:
20706 /// - `async_`: Run the command asynchronously. Returns a job id
20707 /// immediately.
20708 /// - `group`: Assign the request to a custom stats group.
20709 /// - `body`
20710 pub async fn serve_list<'a>(
20711 &'a self,
20712 async_: Option<bool>,
20713 group: Option<&'a str>,
20714 body: &'a types::ServeListRequest,
20715 ) -> Result<ResponseValue<types::ServeListResponse>, Error<types::RcError>> {
20716 let url = format!("{}/serve/list", self.baseurl,);
20717 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20718 header_map.append(
20719 ::reqwest::header::HeaderName::from_static("api-version"),
20720 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20721 );
20722 #[allow(unused_mut)]
20723 let mut request = self
20724 .client
20725 .post(url)
20726 .header(
20727 ::reqwest::header::ACCEPT,
20728 ::reqwest::header::HeaderValue::from_static("application/json"),
20729 )
20730 .json(&body)
20731 .query(&progenitor_client::QueryParam::new("_async", &async_))
20732 .query(&progenitor_client::QueryParam::new("_group", &group))
20733 .headers(header_map)
20734 .build()?;
20735 let info = OperationInfo {
20736 operation_id: "serve_list",
20737 };
20738 self.pre(&mut request, &info).await?;
20739 let result = self.exec(request, &info).await;
20740 self.post(&result, &info).await?;
20741 let response = result?;
20742 match response.status().as_u16() {
20743 200u16 => ResponseValue::from_response(response).await,
20744 400u16..=499u16 => Err(Error::ErrorResponse(
20745 ResponseValue::from_response(response).await?,
20746 )),
20747 500u16..=599u16 => Err(Error::ErrorResponse(
20748 ResponseValue::from_response(response).await?,
20749 )),
20750 _ => Err(Error::UnexpectedResponse(response)),
20751 }
20752 }
20753
20754 ///Start serve instance
20755 ///
20756 ///Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with
20757 /// the provided parameters.
20758 ///
20759 ///Sends a `POST` request to `/serve/start`
20760 ///
20761 ///Arguments:
20762 /// - `async_`: Run the command asynchronously. Returns a job id
20763 /// immediately.
20764 /// - `config`: JSON encoded config overrides applied for this call only.
20765 /// - `filter`: JSON encoded filter overrides applied for this call only.
20766 /// - `group`: Assign the request to a custom stats group.
20767 /// - `addr`: Address and port to bind the server to, such as `:5572` or
20768 /// `localhost:8080`.
20769 /// - `fs`: Remote path that will be served.
20770 /// - `params`: Additional arbitrary parameters allowed.
20771 /// - `type_`: Type of server to start (e.g. `http`, `webdav`, `ftp`,
20772 /// `sftp`).
20773 /// - `body`
20774 pub async fn serve_start<'a>(
20775 &'a self,
20776 async_: Option<bool>,
20777 config: Option<&'a str>,
20778 filter: Option<&'a str>,
20779 group: Option<&'a str>,
20780 addr: Option<&'a str>,
20781 fs: Option<&'a str>,
20782 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
20783 type_: Option<&'a str>,
20784 body: &'a types::ServeStartRequest,
20785 ) -> Result<ResponseValue<types::ServeStartResponse>, Error<types::RcError>> {
20786 let url = format!("{}/serve/start", self.baseurl,);
20787 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20788 header_map.append(
20789 ::reqwest::header::HeaderName::from_static("api-version"),
20790 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20791 );
20792 #[allow(unused_mut)]
20793 let mut request = self
20794 .client
20795 .post(url)
20796 .header(
20797 ::reqwest::header::ACCEPT,
20798 ::reqwest::header::HeaderValue::from_static("application/json"),
20799 )
20800 .json(&body)
20801 .query(&progenitor_client::QueryParam::new("_async", &async_))
20802 .query(&progenitor_client::QueryParam::new("_config", &config))
20803 .query(&progenitor_client::QueryParam::new("_filter", &filter))
20804 .query(&progenitor_client::QueryParam::new("_group", &group))
20805 .query(&progenitor_client::QueryParam::new("addr", &addr))
20806 .query(&progenitor_client::QueryParam::new("fs", &fs))
20807 .query(&progenitor_client::QueryParam::new("params", ¶ms))
20808 .query(&progenitor_client::QueryParam::new("type", &type_))
20809 .headers(header_map)
20810 .build()?;
20811 let info = OperationInfo {
20812 operation_id: "serve_start",
20813 };
20814 self.pre(&mut request, &info).await?;
20815 let result = self.exec(request, &info).await;
20816 self.post(&result, &info).await?;
20817 let response = result?;
20818 match response.status().as_u16() {
20819 200u16 => ResponseValue::from_response(response).await,
20820 400u16..=499u16 => Err(Error::ErrorResponse(
20821 ResponseValue::from_response(response).await?,
20822 )),
20823 500u16..=599u16 => Err(Error::ErrorResponse(
20824 ResponseValue::from_response(response).await?,
20825 )),
20826 _ => Err(Error::UnexpectedResponse(response)),
20827 }
20828 }
20829
20830 ///Stop serve instance
20831 ///
20832 ///Stops a running `serve` instance identified by its ID.
20833 ///
20834 ///Sends a `POST` request to `/serve/stop`
20835 ///
20836 ///Arguments:
20837 /// - `async_`: Run the command asynchronously. Returns a job id
20838 /// immediately.
20839 /// - `group`: Assign the request to a custom stats group.
20840 /// - `id`: Identifier of the running serve instance returned by
20841 /// `serve/start`.
20842 /// - `body`
20843 pub async fn serve_stop<'a>(
20844 &'a self,
20845 async_: Option<bool>,
20846 group: Option<&'a str>,
20847 id: Option<&'a str>,
20848 body: &'a types::ServeStopRequest,
20849 ) -> Result<ResponseValue<types::ServeStopResponse>, Error<types::RcError>> {
20850 let url = format!("{}/serve/stop", self.baseurl,);
20851 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20852 header_map.append(
20853 ::reqwest::header::HeaderName::from_static("api-version"),
20854 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20855 );
20856 #[allow(unused_mut)]
20857 let mut request = self
20858 .client
20859 .post(url)
20860 .header(
20861 ::reqwest::header::ACCEPT,
20862 ::reqwest::header::HeaderValue::from_static("application/json"),
20863 )
20864 .json(&body)
20865 .query(&progenitor_client::QueryParam::new("_async", &async_))
20866 .query(&progenitor_client::QueryParam::new("_group", &group))
20867 .query(&progenitor_client::QueryParam::new("id", &id))
20868 .headers(header_map)
20869 .build()?;
20870 let info = OperationInfo {
20871 operation_id: "serve_stop",
20872 };
20873 self.pre(&mut request, &info).await?;
20874 let result = self.exec(request, &info).await;
20875 self.post(&result, &info).await?;
20876 let response = result?;
20877 match response.status().as_u16() {
20878 200u16 => ResponseValue::from_response(response).await,
20879 400u16..=499u16 => Err(Error::ErrorResponse(
20880 ResponseValue::from_response(response).await?,
20881 )),
20882 500u16..=599u16 => Err(Error::ErrorResponse(
20883 ResponseValue::from_response(response).await?,
20884 )),
20885 _ => Err(Error::UnexpectedResponse(response)),
20886 }
20887 }
20888
20889 ///Stop all serve instances
20890 ///
20891 ///Stops every active `serve` instance.
20892 ///
20893 ///Sends a `POST` request to `/serve/stopall`
20894 ///
20895 ///Arguments:
20896 /// - `async_`: Run the command asynchronously. Returns a job id
20897 /// immediately.
20898 /// - `group`: Assign the request to a custom stats group.
20899 /// - `body`
20900 pub async fn serve_stopall<'a>(
20901 &'a self,
20902 async_: Option<bool>,
20903 group: Option<&'a str>,
20904 body: &'a types::ServeStopallRequest,
20905 ) -> Result<ResponseValue<types::ServeStopallResponse>, Error<types::RcError>> {
20906 let url = format!("{}/serve/stopall", self.baseurl,);
20907 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20908 header_map.append(
20909 ::reqwest::header::HeaderName::from_static("api-version"),
20910 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20911 );
20912 #[allow(unused_mut)]
20913 let mut request = self
20914 .client
20915 .post(url)
20916 .header(
20917 ::reqwest::header::ACCEPT,
20918 ::reqwest::header::HeaderValue::from_static("application/json"),
20919 )
20920 .json(&body)
20921 .query(&progenitor_client::QueryParam::new("_async", &async_))
20922 .query(&progenitor_client::QueryParam::new("_group", &group))
20923 .headers(header_map)
20924 .build()?;
20925 let info = OperationInfo {
20926 operation_id: "serve_stopall",
20927 };
20928 self.pre(&mut request, &info).await?;
20929 let result = self.exec(request, &info).await;
20930 self.post(&result, &info).await?;
20931 let response = result?;
20932 match response.status().as_u16() {
20933 200u16 => ResponseValue::from_response(response).await,
20934 400u16..=499u16 => Err(Error::ErrorResponse(
20935 ResponseValue::from_response(response).await?,
20936 )),
20937 500u16..=599u16 => Err(Error::ErrorResponse(
20938 ResponseValue::from_response(response).await?,
20939 )),
20940 _ => Err(Error::UnexpectedResponse(response)),
20941 }
20942 }
20943
20944 ///List serve types
20945 ///
20946 ///Returns the list of supported `rclone serve` protocols.
20947 ///
20948 ///Sends a `POST` request to `/serve/types`
20949 ///
20950 ///Arguments:
20951 /// - `async_`: Run the command asynchronously. Returns a job id
20952 /// immediately.
20953 /// - `group`: Assign the request to a custom stats group.
20954 /// - `body`
20955 pub async fn serve_types<'a>(
20956 &'a self,
20957 async_: Option<bool>,
20958 group: Option<&'a str>,
20959 body: &'a types::ServeTypesRequest,
20960 ) -> Result<ResponseValue<types::ServeTypesResponse>, Error<types::RcError>> {
20961 let url = format!("{}/serve/types", self.baseurl,);
20962 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
20963 header_map.append(
20964 ::reqwest::header::HeaderName::from_static("api-version"),
20965 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
20966 );
20967 #[allow(unused_mut)]
20968 let mut request = self
20969 .client
20970 .post(url)
20971 .header(
20972 ::reqwest::header::ACCEPT,
20973 ::reqwest::header::HeaderValue::from_static("application/json"),
20974 )
20975 .json(&body)
20976 .query(&progenitor_client::QueryParam::new("_async", &async_))
20977 .query(&progenitor_client::QueryParam::new("_group", &group))
20978 .headers(header_map)
20979 .build()?;
20980 let info = OperationInfo {
20981 operation_id: "serve_types",
20982 };
20983 self.pre(&mut request, &info).await?;
20984 let result = self.exec(request, &info).await;
20985 self.post(&result, &info).await?;
20986 let response = result?;
20987 match response.status().as_u16() {
20988 200u16 => ResponseValue::from_response(response).await,
20989 400u16..=499u16 => Err(Error::ErrorResponse(
20990 ResponseValue::from_response(response).await?,
20991 )),
20992 500u16..=599u16 => Err(Error::ErrorResponse(
20993 ResponseValue::from_response(response).await?,
20994 )),
20995 _ => Err(Error::UnexpectedResponse(response)),
20996 }
20997 }
20998
20999 ///Forget cached paths
21000 ///
21001 ///Evicts specific files or directories from the VFS directory cache.
21002 ///
21003 ///Sends a `POST` request to `/vfs/forget`
21004 ///
21005 ///Arguments:
21006 /// - `async_`: Run the command asynchronously. Returns a job id
21007 /// immediately.
21008 /// - `group`: Assign the request to a custom stats group.
21009 /// - `fs`: Optional VFS identifier to target; required when more than one
21010 /// VFS is active.
21011 /// - `params`: Additional arbitrary parameters allowed.
21012 /// - `body`
21013 pub async fn vfs_forget<'a>(
21014 &'a self,
21015 async_: Option<bool>,
21016 group: Option<&'a str>,
21017 fs: Option<&'a str>,
21018 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
21019 body: &'a types::VfsForgetRequest,
21020 ) -> Result<ResponseValue<types::VfsForgetResponse>, Error<types::RcError>> {
21021 let url = format!("{}/vfs/forget", self.baseurl,);
21022 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21023 header_map.append(
21024 ::reqwest::header::HeaderName::from_static("api-version"),
21025 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21026 );
21027 #[allow(unused_mut)]
21028 let mut request = self
21029 .client
21030 .post(url)
21031 .header(
21032 ::reqwest::header::ACCEPT,
21033 ::reqwest::header::HeaderValue::from_static("application/json"),
21034 )
21035 .json(&body)
21036 .query(&progenitor_client::QueryParam::new("_async", &async_))
21037 .query(&progenitor_client::QueryParam::new("_group", &group))
21038 .query(&progenitor_client::QueryParam::new("fs", &fs))
21039 .query(&progenitor_client::QueryParam::new("params", ¶ms))
21040 .headers(header_map)
21041 .build()?;
21042 let info = OperationInfo {
21043 operation_id: "vfs_forget",
21044 };
21045 self.pre(&mut request, &info).await?;
21046 let result = self.exec(request, &info).await;
21047 self.post(&result, &info).await?;
21048 let response = result?;
21049 match response.status().as_u16() {
21050 200u16 => ResponseValue::from_response(response).await,
21051 400u16..=499u16 => Err(Error::ErrorResponse(
21052 ResponseValue::from_response(response).await?,
21053 )),
21054 500u16..=599u16 => Err(Error::ErrorResponse(
21055 ResponseValue::from_response(response).await?,
21056 )),
21057 _ => Err(Error::UnexpectedResponse(response)),
21058 }
21059 }
21060
21061 ///List VFS instances
21062 ///
21063 ///Lists the active VFS instances and their identifiers.
21064 ///
21065 ///Sends a `POST` request to `/vfs/list`
21066 ///
21067 ///Arguments:
21068 /// - `async_`: Run the command asynchronously. Returns a job id
21069 /// immediately.
21070 /// - `group`: Assign the request to a custom stats group.
21071 /// - `fs`: Optional VFS identifier; omit to list all active VFS instances.
21072 /// - `body`
21073 pub async fn vfs_list<'a>(
21074 &'a self,
21075 async_: Option<bool>,
21076 group: Option<&'a str>,
21077 fs: Option<&'a str>,
21078 body: &'a types::VfsListRequest,
21079 ) -> Result<ResponseValue<types::VfsListResponse>, Error<types::RcError>> {
21080 let url = format!("{}/vfs/list", self.baseurl,);
21081 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21082 header_map.append(
21083 ::reqwest::header::HeaderName::from_static("api-version"),
21084 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21085 );
21086 #[allow(unused_mut)]
21087 let mut request = self
21088 .client
21089 .post(url)
21090 .header(
21091 ::reqwest::header::ACCEPT,
21092 ::reqwest::header::HeaderValue::from_static("application/json"),
21093 )
21094 .json(&body)
21095 .query(&progenitor_client::QueryParam::new("_async", &async_))
21096 .query(&progenitor_client::QueryParam::new("_group", &group))
21097 .query(&progenitor_client::QueryParam::new("fs", &fs))
21098 .headers(header_map)
21099 .build()?;
21100 let info = OperationInfo {
21101 operation_id: "vfs_list",
21102 };
21103 self.pre(&mut request, &info).await?;
21104 let result = self.exec(request, &info).await;
21105 self.post(&result, &info).await?;
21106 let response = result?;
21107 match response.status().as_u16() {
21108 200u16 => ResponseValue::from_response(response).await,
21109 400u16..=499u16 => Err(Error::ErrorResponse(
21110 ResponseValue::from_response(response).await?,
21111 )),
21112 500u16..=599u16 => Err(Error::ErrorResponse(
21113 ResponseValue::from_response(response).await?,
21114 )),
21115 _ => Err(Error::UnexpectedResponse(response)),
21116 }
21117 }
21118
21119 ///Get or set poll interval
21120 ///
21121 ///Reads or updates the VFS poll interval duration, optionally waiting for
21122 /// the change to apply.
21123 ///
21124 ///Sends a `POST` request to `/vfs/poll-interval`
21125 ///
21126 ///Arguments:
21127 /// - `async_`: Run the command asynchronously. Returns a job id
21128 /// immediately.
21129 /// - `group`: Assign the request to a custom stats group.
21130 /// - `fs`: Optional VFS identifier whose poll interval should be queried or
21131 /// modified.
21132 /// - `interval`: Duration string (e.g. `5m`) to set as the new poll
21133 /// interval.
21134 /// - `timeout`: Duration to wait for the poll interval change to take
21135 /// effect; `0` waits indefinitely.
21136 /// - `body`
21137 pub async fn vfs_poll_interval<'a>(
21138 &'a self,
21139 async_: Option<bool>,
21140 group: Option<&'a str>,
21141 fs: Option<&'a str>,
21142 interval: Option<&'a str>,
21143 timeout: Option<&'a str>,
21144 body: &'a types::VfsPollIntervalRequest,
21145 ) -> Result<
21146 ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
21147 Error<types::RcError>,
21148 > {
21149 let url = format!("{}/vfs/poll-interval", self.baseurl,);
21150 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21151 header_map.append(
21152 ::reqwest::header::HeaderName::from_static("api-version"),
21153 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21154 );
21155 #[allow(unused_mut)]
21156 let mut request = self
21157 .client
21158 .post(url)
21159 .header(
21160 ::reqwest::header::ACCEPT,
21161 ::reqwest::header::HeaderValue::from_static("application/json"),
21162 )
21163 .json(&body)
21164 .query(&progenitor_client::QueryParam::new("_async", &async_))
21165 .query(&progenitor_client::QueryParam::new("_group", &group))
21166 .query(&progenitor_client::QueryParam::new("fs", &fs))
21167 .query(&progenitor_client::QueryParam::new("interval", &interval))
21168 .query(&progenitor_client::QueryParam::new("timeout", &timeout))
21169 .headers(header_map)
21170 .build()?;
21171 let info = OperationInfo {
21172 operation_id: "vfs_poll_interval",
21173 };
21174 self.pre(&mut request, &info).await?;
21175 let result = self.exec(request, &info).await;
21176 self.post(&result, &info).await?;
21177 let response = result?;
21178 match response.status().as_u16() {
21179 200u16 => ResponseValue::from_response(response).await,
21180 400u16..=499u16 => Err(Error::ErrorResponse(
21181 ResponseValue::from_response(response).await?,
21182 )),
21183 500u16..=599u16 => Err(Error::ErrorResponse(
21184 ResponseValue::from_response(response).await?,
21185 )),
21186 _ => Err(Error::UnexpectedResponse(response)),
21187 }
21188 }
21189
21190 ///Inspect upload queue
21191 ///
21192 ///Returns the contents of the VFS upload queue.
21193 ///
21194 ///Sends a `POST` request to `/vfs/queue`
21195 ///
21196 ///Arguments:
21197 /// - `async_`: Run the command asynchronously. Returns a job id
21198 /// immediately.
21199 /// - `group`: Assign the request to a custom stats group.
21200 /// - `fs`: Optional VFS identifier whose upload queue should be inspected.
21201 /// - `body`
21202 pub async fn vfs_queue<'a>(
21203 &'a self,
21204 async_: Option<bool>,
21205 group: Option<&'a str>,
21206 fs: Option<&'a str>,
21207 body: &'a types::VfsQueueRequest,
21208 ) -> Result<ResponseValue<types::VfsQueueResponse>, Error<types::RcError>> {
21209 let url = format!("{}/vfs/queue", self.baseurl,);
21210 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21211 header_map.append(
21212 ::reqwest::header::HeaderName::from_static("api-version"),
21213 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21214 );
21215 #[allow(unused_mut)]
21216 let mut request = self
21217 .client
21218 .post(url)
21219 .header(
21220 ::reqwest::header::ACCEPT,
21221 ::reqwest::header::HeaderValue::from_static("application/json"),
21222 )
21223 .json(&body)
21224 .query(&progenitor_client::QueryParam::new("_async", &async_))
21225 .query(&progenitor_client::QueryParam::new("_group", &group))
21226 .query(&progenitor_client::QueryParam::new("fs", &fs))
21227 .headers(header_map)
21228 .build()?;
21229 let info = OperationInfo {
21230 operation_id: "vfs_queue",
21231 };
21232 self.pre(&mut request, &info).await?;
21233 let result = self.exec(request, &info).await;
21234 self.post(&result, &info).await?;
21235 let response = result?;
21236 match response.status().as_u16() {
21237 200u16 => ResponseValue::from_response(response).await,
21238 400u16..=499u16 => Err(Error::ErrorResponse(
21239 ResponseValue::from_response(response).await?,
21240 )),
21241 500u16..=599u16 => Err(Error::ErrorResponse(
21242 ResponseValue::from_response(response).await?,
21243 )),
21244 _ => Err(Error::UnexpectedResponse(response)),
21245 }
21246 }
21247
21248 ///Adjust queue expiry
21249 ///
21250 ///Sets the expiry time of a queued VFS upload item, optionally relative to
21251 /// its current value.
21252 ///
21253 ///Sends a `POST` request to `/vfs/queue-set-expiry`
21254 ///
21255 ///Arguments:
21256 /// - `async_`: Run the command asynchronously. Returns a job id
21257 /// immediately.
21258 /// - `group`: Assign the request to a custom stats group.
21259 /// - `expiry`: New eligibility time in seconds (may be negative for
21260 /// immediate upload).
21261 /// - `fs`: Optional VFS identifier for the queued item.
21262 /// - `id`: Queue item ID as returned by `vfs/queue`.
21263 /// - `relative`: Set to true to treat `expiry` as relative to the current
21264 /// value.
21265 /// - `body`
21266 pub async fn vfs_queue_set_expiry<'a>(
21267 &'a self,
21268 async_: Option<bool>,
21269 group: Option<&'a str>,
21270 expiry: Option<f64>,
21271 fs: Option<&'a str>,
21272 id: Option<i64>,
21273 relative: Option<bool>,
21274 body: &'a types::VfsQueueSetExpiryRequest,
21275 ) -> Result<ResponseValue<types::VfsQueueSetExpiryResponse>, Error<types::RcError>> {
21276 let url = format!("{}/vfs/queue-set-expiry", self.baseurl,);
21277 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21278 header_map.append(
21279 ::reqwest::header::HeaderName::from_static("api-version"),
21280 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21281 );
21282 #[allow(unused_mut)]
21283 let mut request = self
21284 .client
21285 .post(url)
21286 .header(
21287 ::reqwest::header::ACCEPT,
21288 ::reqwest::header::HeaderValue::from_static("application/json"),
21289 )
21290 .json(&body)
21291 .query(&progenitor_client::QueryParam::new("_async", &async_))
21292 .query(&progenitor_client::QueryParam::new("_group", &group))
21293 .query(&progenitor_client::QueryParam::new("expiry", &expiry))
21294 .query(&progenitor_client::QueryParam::new("fs", &fs))
21295 .query(&progenitor_client::QueryParam::new("id", &id))
21296 .query(&progenitor_client::QueryParam::new("relative", &relative))
21297 .headers(header_map)
21298 .build()?;
21299 let info = OperationInfo {
21300 operation_id: "vfs_queue_set_expiry",
21301 };
21302 self.pre(&mut request, &info).await?;
21303 let result = self.exec(request, &info).await;
21304 self.post(&result, &info).await?;
21305 let response = result?;
21306 match response.status().as_u16() {
21307 200u16 => ResponseValue::from_response(response).await,
21308 400u16..=499u16 => Err(Error::ErrorResponse(
21309 ResponseValue::from_response(response).await?,
21310 )),
21311 500u16..=599u16 => Err(Error::ErrorResponse(
21312 ResponseValue::from_response(response).await?,
21313 )),
21314 _ => Err(Error::UnexpectedResponse(response)),
21315 }
21316 }
21317
21318 ///Refresh directory cache
21319 ///
21320 ///Refreshes one or more directories in the VFS cache, optionally
21321 /// recursively.
21322 ///
21323 ///Sends a `POST` request to `/vfs/refresh`
21324 ///
21325 ///Arguments:
21326 /// - `async_`: Run the command asynchronously. Returns a job id
21327 /// immediately.
21328 /// - `group`: Assign the request to a custom stats group.
21329 /// - `fs`: Optional VFS identifier whose directory cache should be
21330 /// refreshed.
21331 /// - `params`: Additional arbitrary parameters allowed.
21332 /// - `recursive`: Set to true to refresh entire directory trees.
21333 /// - `body`
21334 pub async fn vfs_refresh<'a>(
21335 &'a self,
21336 async_: Option<bool>,
21337 group: Option<&'a str>,
21338 fs: Option<&'a str>,
21339 params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
21340 recursive: Option<bool>,
21341 body: &'a types::VfsRefreshRequest,
21342 ) -> Result<ResponseValue<types::VfsRefreshResponse>, Error<types::RcError>> {
21343 let url = format!("{}/vfs/refresh", self.baseurl,);
21344 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21345 header_map.append(
21346 ::reqwest::header::HeaderName::from_static("api-version"),
21347 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21348 );
21349 #[allow(unused_mut)]
21350 let mut request = self
21351 .client
21352 .post(url)
21353 .header(
21354 ::reqwest::header::ACCEPT,
21355 ::reqwest::header::HeaderValue::from_static("application/json"),
21356 )
21357 .json(&body)
21358 .query(&progenitor_client::QueryParam::new("_async", &async_))
21359 .query(&progenitor_client::QueryParam::new("_group", &group))
21360 .query(&progenitor_client::QueryParam::new("fs", &fs))
21361 .query(&progenitor_client::QueryParam::new("params", ¶ms))
21362 .query(&progenitor_client::QueryParam::new("recursive", &recursive))
21363 .headers(header_map)
21364 .build()?;
21365 let info = OperationInfo {
21366 operation_id: "vfs_refresh",
21367 };
21368 self.pre(&mut request, &info).await?;
21369 let result = self.exec(request, &info).await;
21370 self.post(&result, &info).await?;
21371 let response = result?;
21372 match response.status().as_u16() {
21373 200u16 => ResponseValue::from_response(response).await,
21374 400u16..=499u16 => Err(Error::ErrorResponse(
21375 ResponseValue::from_response(response).await?,
21376 )),
21377 500u16..=599u16 => Err(Error::ErrorResponse(
21378 ResponseValue::from_response(response).await?,
21379 )),
21380 _ => Err(Error::UnexpectedResponse(response)),
21381 }
21382 }
21383
21384 ///Show VFS stats
21385 ///
21386 ///Returns VFS statistics including disk cache usage and metadata cache
21387 /// counters.
21388 ///
21389 ///Sends a `POST` request to `/vfs/stats`
21390 ///
21391 ///Arguments:
21392 /// - `async_`: Run the command asynchronously. Returns a job id
21393 /// immediately.
21394 /// - `group`: Assign the request to a custom stats group.
21395 /// - `fs`: Optional VFS identifier whose statistics should be returned.
21396 /// - `body`
21397 pub async fn vfs_stats<'a>(
21398 &'a self,
21399 async_: Option<bool>,
21400 group: Option<&'a str>,
21401 fs: Option<&'a str>,
21402 body: &'a types::VfsStatsRequest,
21403 ) -> Result<ResponseValue<types::VfsStatsResponse>, Error<types::RcError>> {
21404 let url = format!("{}/vfs/stats", self.baseurl,);
21405 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21406 header_map.append(
21407 ::reqwest::header::HeaderName::from_static("api-version"),
21408 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21409 );
21410 #[allow(unused_mut)]
21411 let mut request = self
21412 .client
21413 .post(url)
21414 .header(
21415 ::reqwest::header::ACCEPT,
21416 ::reqwest::header::HeaderValue::from_static("application/json"),
21417 )
21418 .json(&body)
21419 .query(&progenitor_client::QueryParam::new("_async", &async_))
21420 .query(&progenitor_client::QueryParam::new("_group", &group))
21421 .query(&progenitor_client::QueryParam::new("fs", &fs))
21422 .headers(header_map)
21423 .build()?;
21424 let info = OperationInfo {
21425 operation_id: "vfs_stats",
21426 };
21427 self.pre(&mut request, &info).await?;
21428 let result = self.exec(request, &info).await;
21429 self.post(&result, &info).await?;
21430 let response = result?;
21431 match response.status().as_u16() {
21432 200u16 => ResponseValue::from_response(response).await,
21433 400u16..=499u16 => Err(Error::ErrorResponse(
21434 ResponseValue::from_response(response).await?,
21435 )),
21436 500u16..=599u16 => Err(Error::ErrorResponse(
21437 ResponseValue::from_response(response).await?,
21438 )),
21439 _ => Err(Error::UnexpectedResponse(response)),
21440 }
21441 }
21442
21443 ///Install plugin
21444 ///
21445 ///Downloads and installs a plugin into the WebUI from the provided
21446 /// repository URL.
21447 ///
21448 ///Sends a `POST` request to `/pluginsctl/addPlugin`
21449 ///
21450 ///Arguments:
21451 /// - `async_`: Run the command asynchronously. Returns a job id
21452 /// immediately.
21453 /// - `group`: Assign the request to a custom stats group.
21454 /// - `url`: Repository URL of the plugin to install.
21455 /// - `body`
21456 pub async fn pluginsctl_add_plugin<'a>(
21457 &'a self,
21458 async_: Option<bool>,
21459 group: Option<&'a str>,
21460 url: Option<&'a str>,
21461 body: &'a types::PluginsctlAddPluginRequest,
21462 ) -> Result<ResponseValue<types::PluginsctlAddPluginResponse>, Error<types::RcError>> {
21463 let _url = format!("{}/pluginsctl/addPlugin", self.baseurl,);
21464 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21465 header_map.append(
21466 ::reqwest::header::HeaderName::from_static("api-version"),
21467 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21468 );
21469 #[allow(unused_mut)]
21470 let mut request = self
21471 .client
21472 .post(_url)
21473 .header(
21474 ::reqwest::header::ACCEPT,
21475 ::reqwest::header::HeaderValue::from_static("application/json"),
21476 )
21477 .json(&body)
21478 .query(&progenitor_client::QueryParam::new("_async", &async_))
21479 .query(&progenitor_client::QueryParam::new("_group", &group))
21480 .query(&progenitor_client::QueryParam::new("url", &url))
21481 .headers(header_map)
21482 .build()?;
21483 let info = OperationInfo {
21484 operation_id: "pluginsctl_add_plugin",
21485 };
21486 self.pre(&mut request, &info).await?;
21487 let result = self.exec(request, &info).await;
21488 self.post(&result, &info).await?;
21489 let response = result?;
21490 match response.status().as_u16() {
21491 200u16 => ResponseValue::from_response(response).await,
21492 400u16..=499u16 => Err(Error::ErrorResponse(
21493 ResponseValue::from_response(response).await?,
21494 )),
21495 500u16..=599u16 => Err(Error::ErrorResponse(
21496 ResponseValue::from_response(response).await?,
21497 )),
21498 _ => Err(Error::UnexpectedResponse(response)),
21499 }
21500 }
21501
21502 ///Filter plugins by MIME type
21503 ///
21504 ///Returns plugins matching the requested MIME type and optional plugin
21505 /// type.
21506 ///
21507 ///Sends a `POST` request to `/pluginsctl/getPluginsForType`
21508 ///
21509 ///Arguments:
21510 /// - `async_`: Run the command asynchronously. Returns a job id
21511 /// immediately.
21512 /// - `group`: Assign the request to a custom stats group.
21513 /// - `plugin_type`: Filter results by plugin type (e.g. `test`).
21514 /// - `type_`: MIME type to match when listing plugins.
21515 /// - `body`
21516 pub async fn pluginsctl_get_plugins_for_type<'a>(
21517 &'a self,
21518 async_: Option<bool>,
21519 group: Option<&'a str>,
21520 plugin_type: Option<&'a str>,
21521 type_: Option<&'a str>,
21522 body: &'a types::PluginsctlGetPluginsForTypeRequest,
21523 ) -> Result<ResponseValue<types::PluginsctlGetPluginsForTypeResponse>, Error<types::RcError>>
21524 {
21525 let url = format!("{}/pluginsctl/getPluginsForType", self.baseurl,);
21526 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21527 header_map.append(
21528 ::reqwest::header::HeaderName::from_static("api-version"),
21529 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21530 );
21531 #[allow(unused_mut)]
21532 let mut request = self
21533 .client
21534 .post(url)
21535 .header(
21536 ::reqwest::header::ACCEPT,
21537 ::reqwest::header::HeaderValue::from_static("application/json"),
21538 )
21539 .json(&body)
21540 .query(&progenitor_client::QueryParam::new("_async", &async_))
21541 .query(&progenitor_client::QueryParam::new("_group", &group))
21542 .query(&progenitor_client::QueryParam::new(
21543 "pluginType",
21544 &plugin_type,
21545 ))
21546 .query(&progenitor_client::QueryParam::new("type", &type_))
21547 .headers(header_map)
21548 .build()?;
21549 let info = OperationInfo {
21550 operation_id: "pluginsctl_get_plugins_for_type",
21551 };
21552 self.pre(&mut request, &info).await?;
21553 let result = self.exec(request, &info).await;
21554 self.post(&result, &info).await?;
21555 let response = result?;
21556 match response.status().as_u16() {
21557 200u16 => ResponseValue::from_response(response).await,
21558 400u16..=499u16 => Err(Error::ErrorResponse(
21559 ResponseValue::from_response(response).await?,
21560 )),
21561 500u16..=599u16 => Err(Error::ErrorResponse(
21562 ResponseValue::from_response(response).await?,
21563 )),
21564 _ => Err(Error::UnexpectedResponse(response)),
21565 }
21566 }
21567
21568 ///List installed plugins
21569 ///
21570 ///Returns metadata for installed production and test plugins.
21571 ///
21572 ///Sends a `POST` request to `/pluginsctl/listPlugins`
21573 ///
21574 ///Arguments:
21575 /// - `async_`: Run the command asynchronously. Returns a job id
21576 /// immediately.
21577 /// - `group`: Assign the request to a custom stats group.
21578 /// - `body`
21579 pub async fn pluginsctl_list_plugins<'a>(
21580 &'a self,
21581 async_: Option<bool>,
21582 group: Option<&'a str>,
21583 body: &'a types::PluginsctlListPluginsRequest,
21584 ) -> Result<ResponseValue<types::PluginsctlListPluginsResponse>, Error<types::RcError>> {
21585 let url = format!("{}/pluginsctl/listPlugins", self.baseurl,);
21586 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21587 header_map.append(
21588 ::reqwest::header::HeaderName::from_static("api-version"),
21589 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21590 );
21591 #[allow(unused_mut)]
21592 let mut request = self
21593 .client
21594 .post(url)
21595 .header(
21596 ::reqwest::header::ACCEPT,
21597 ::reqwest::header::HeaderValue::from_static("application/json"),
21598 )
21599 .json(&body)
21600 .query(&progenitor_client::QueryParam::new("_async", &async_))
21601 .query(&progenitor_client::QueryParam::new("_group", &group))
21602 .headers(header_map)
21603 .build()?;
21604 let info = OperationInfo {
21605 operation_id: "pluginsctl_list_plugins",
21606 };
21607 self.pre(&mut request, &info).await?;
21608 let result = self.exec(request, &info).await;
21609 self.post(&result, &info).await?;
21610 let response = result?;
21611 match response.status().as_u16() {
21612 200u16 => ResponseValue::from_response(response).await,
21613 400u16..=499u16 => Err(Error::ErrorResponse(
21614 ResponseValue::from_response(response).await?,
21615 )),
21616 500u16..=599u16 => Err(Error::ErrorResponse(
21617 ResponseValue::from_response(response).await?,
21618 )),
21619 _ => Err(Error::UnexpectedResponse(response)),
21620 }
21621 }
21622
21623 ///List installed test plugins
21624 ///
21625 ///Returns metadata for installed test plugins.
21626 ///
21627 ///Sends a `POST` request to `/pluginsctl/listTestPlugins`
21628 ///
21629 ///Arguments:
21630 /// - `async_`: Run the command asynchronously. Returns a job id
21631 /// immediately.
21632 /// - `group`: Assign the request to a custom stats group.
21633 /// - `body`
21634 pub async fn pluginsctl_list_test_plugins<'a>(
21635 &'a self,
21636 async_: Option<bool>,
21637 group: Option<&'a str>,
21638 body: &'a types::PluginsctlListTestPluginsRequest,
21639 ) -> Result<ResponseValue<types::PluginsctlListTestPluginsResponse>, Error<types::RcError>>
21640 {
21641 let url = format!("{}/pluginsctl/listTestPlugins", self.baseurl,);
21642 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21643 header_map.append(
21644 ::reqwest::header::HeaderName::from_static("api-version"),
21645 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21646 );
21647 #[allow(unused_mut)]
21648 let mut request = self
21649 .client
21650 .post(url)
21651 .header(
21652 ::reqwest::header::ACCEPT,
21653 ::reqwest::header::HeaderValue::from_static("application/json"),
21654 )
21655 .json(&body)
21656 .query(&progenitor_client::QueryParam::new("_async", &async_))
21657 .query(&progenitor_client::QueryParam::new("_group", &group))
21658 .headers(header_map)
21659 .build()?;
21660 let info = OperationInfo {
21661 operation_id: "pluginsctl_list_test_plugins",
21662 };
21663 self.pre(&mut request, &info).await?;
21664 let result = self.exec(request, &info).await;
21665 self.post(&result, &info).await?;
21666 let response = result?;
21667 match response.status().as_u16() {
21668 200u16 => ResponseValue::from_response(response).await,
21669 400u16..=499u16 => Err(Error::ErrorResponse(
21670 ResponseValue::from_response(response).await?,
21671 )),
21672 500u16..=599u16 => Err(Error::ErrorResponse(
21673 ResponseValue::from_response(response).await?,
21674 )),
21675 _ => Err(Error::UnexpectedResponse(response)),
21676 }
21677 }
21678
21679 ///Remove plugin
21680 ///
21681 ///Uninstalls a plugin from the WebUI.
21682 ///
21683 ///Sends a `POST` request to `/pluginsctl/removePlugin`
21684 ///
21685 ///Arguments:
21686 /// - `async_`: Run the command asynchronously. Returns a job id
21687 /// immediately.
21688 /// - `group`: Assign the request to a custom stats group.
21689 /// - `name`: Name of the plugin to uninstall.
21690 /// - `body`
21691 pub async fn pluginsctl_remove_plugin<'a>(
21692 &'a self,
21693 async_: Option<bool>,
21694 group: Option<&'a str>,
21695 name: Option<&'a str>,
21696 body: &'a types::PluginsctlRemovePluginRequest,
21697 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
21698 let url = format!("{}/pluginsctl/removePlugin", self.baseurl,);
21699 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21700 header_map.append(
21701 ::reqwest::header::HeaderName::from_static("api-version"),
21702 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21703 );
21704 #[allow(unused_mut)]
21705 let mut request = self
21706 .client
21707 .post(url)
21708 .header(
21709 ::reqwest::header::ACCEPT,
21710 ::reqwest::header::HeaderValue::from_static("application/json"),
21711 )
21712 .json(&body)
21713 .query(&progenitor_client::QueryParam::new("_async", &async_))
21714 .query(&progenitor_client::QueryParam::new("_group", &group))
21715 .query(&progenitor_client::QueryParam::new("name", &name))
21716 .headers(header_map)
21717 .build()?;
21718 let info = OperationInfo {
21719 operation_id: "pluginsctl_remove_plugin",
21720 };
21721 self.pre(&mut request, &info).await?;
21722 let result = self.exec(request, &info).await;
21723 self.post(&result, &info).await?;
21724 let response = result?;
21725 match response.status().as_u16() {
21726 200u16 => Ok(ResponseValue::empty(response)),
21727 400u16..=499u16 => Err(Error::ErrorResponse(
21728 ResponseValue::from_response(response).await?,
21729 )),
21730 500u16..=599u16 => Err(Error::ErrorResponse(
21731 ResponseValue::from_response(response).await?,
21732 )),
21733 _ => Err(Error::UnexpectedResponse(response)),
21734 }
21735 }
21736
21737 ///Remove test plugin
21738 ///
21739 ///Uninstalls a test plugin from the WebUI.
21740 ///
21741 ///Sends a `POST` request to `/pluginsctl/removeTestPlugin`
21742 ///
21743 ///Arguments:
21744 /// - `async_`: Run the command asynchronously. Returns a job id
21745 /// immediately.
21746 /// - `group`: Assign the request to a custom stats group.
21747 /// - `name`: Name of the test plugin to uninstall.
21748 /// - `body`
21749 pub async fn pluginsctl_remove_test_plugin<'a>(
21750 &'a self,
21751 async_: Option<bool>,
21752 group: Option<&'a str>,
21753 name: Option<&'a str>,
21754 body: &'a types::PluginsctlRemoveTestPluginRequest,
21755 ) -> Result<ResponseValue<()>, Error<types::RcError>> {
21756 let url = format!("{}/pluginsctl/removeTestPlugin", self.baseurl,);
21757 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
21758 header_map.append(
21759 ::reqwest::header::HeaderName::from_static("api-version"),
21760 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
21761 );
21762 #[allow(unused_mut)]
21763 let mut request = self
21764 .client
21765 .post(url)
21766 .header(
21767 ::reqwest::header::ACCEPT,
21768 ::reqwest::header::HeaderValue::from_static("application/json"),
21769 )
21770 .json(&body)
21771 .query(&progenitor_client::QueryParam::new("_async", &async_))
21772 .query(&progenitor_client::QueryParam::new("_group", &group))
21773 .query(&progenitor_client::QueryParam::new("name", &name))
21774 .headers(header_map)
21775 .build()?;
21776 let info = OperationInfo {
21777 operation_id: "pluginsctl_remove_test_plugin",
21778 };
21779 self.pre(&mut request, &info).await?;
21780 let result = self.exec(request, &info).await;
21781 self.post(&result, &info).await?;
21782 let response = result?;
21783 match response.status().as_u16() {
21784 200u16 => Ok(ResponseValue::empty(response)),
21785 400u16..=499u16 => Err(Error::ErrorResponse(
21786 ResponseValue::from_response(response).await?,
21787 )),
21788 500u16..=599u16 => Err(Error::ErrorResponse(
21789 ResponseValue::from_response(response).await?,
21790 )),
21791 _ => Err(Error::UnexpectedResponse(response)),
21792 }
21793 }
21794}
21795
21796/// Items consumers will typically use such as the Client.
21797pub mod prelude {
21798 #[allow(unused_imports)]
21799 pub use super::Client;
21800}