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    ///`BackendCommandPrefer`
39    ///
40    /// <details><summary>JSON schema</summary>
41    ///
42    /// ```json
43    ///{
44    ///  "type": "string",
45    ///  "enum": [
46    ///    "respond-async"
47    ///  ]
48    ///}
49    /// ```
50    /// </details>
51    #[derive(
52        :: serde :: Deserialize,
53        :: serde :: Serialize,
54        Clone,
55        Copy,
56        Debug,
57        Eq,
58        Hash,
59        Ord,
60        PartialEq,
61        PartialOrd,
62    )]
63    pub enum BackendCommandPrefer {
64        #[serde(rename = "respond-async")]
65        RespondAsync,
66    }
67
68    impl ::std::convert::From<&Self> for BackendCommandPrefer {
69        fn from(value: &BackendCommandPrefer) -> Self {
70            value.clone()
71        }
72    }
73
74    impl ::std::fmt::Display for BackendCommandPrefer {
75        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
76            match *self {
77                Self::RespondAsync => f.write_str("respond-async"),
78            }
79        }
80    }
81
82    impl ::std::str::FromStr for BackendCommandPrefer {
83        type Err = self::error::ConversionError;
84        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
85            match value {
86                "respond-async" => Ok(Self::RespondAsync),
87                _ => Err("invalid value".into()),
88            }
89        }
90    }
91
92    impl ::std::convert::TryFrom<&str> for BackendCommandPrefer {
93        type Error = self::error::ConversionError;
94        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
95            value.parse()
96        }
97    }
98
99    impl ::std::convert::TryFrom<&::std::string::String> for BackendCommandPrefer {
100        type Error = self::error::ConversionError;
101        fn try_from(
102            value: &::std::string::String,
103        ) -> ::std::result::Result<Self, self::error::ConversionError> {
104            value.parse()
105        }
106    }
107
108    impl ::std::convert::TryFrom<::std::string::String> for BackendCommandPrefer {
109        type Error = self::error::ConversionError;
110        fn try_from(
111            value: ::std::string::String,
112        ) -> ::std::result::Result<Self, self::error::ConversionError> {
113            value.parse()
114        }
115    }
116
117    ///`BackendCommandRequest`
118    ///
119    /// <details><summary>JSON schema</summary>
120    ///
121    /// ```json
122    ///{
123    ///  "type": "object",
124    ///  "properties": {
125    ///    "_async": {
126    ///      "description": "Run the command asynchronously. Returns a job id
127    /// immediately.",
128    ///      "type": "boolean"
129    ///    },
130    ///    "_group": {
131    ///      "description": "Assign the request to a custom stats group.",
132    ///      "type": "string"
133    ///    },
134    ///    "arg": {
135    ///      "description": "Optional positional arguments for the backend
136    /// command.",
137    ///      "type": "array",
138    ///      "items": {
139    ///        "type": "string"
140    ///      }
141    ///    },
142    ///    "command": {
143    ///      "description": "Backend-specific command to invoke.",
144    ///      "type": "string"
145    ///    },
146    ///    "fs": {
147    ///      "description": "Remote name or path the backend command should
148    /// target.",
149    ///      "type": "string"
150    ///    },
151    ///    "opt": {
152    ///      "description": "Backend command options encoded as a JSON string.",
153    ///      "type": "string"
154    ///    }
155    ///  }
156    ///}
157    /// ```
158    /// </details>
159    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
160    pub struct BackendCommandRequest {
161        ///Optional positional arguments for the backend command.
162        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
163        pub arg: ::std::vec::Vec<::std::string::String>,
164        ///Run the command asynchronously. Returns a job id immediately.
165        #[serde(
166            rename = "_async",
167            default,
168            skip_serializing_if = "::std::option::Option::is_none"
169        )]
170        pub async_: ::std::option::Option<bool>,
171        ///Backend-specific command to invoke.
172        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
173        pub command: ::std::option::Option<::std::string::String>,
174        ///Remote name or path the backend command should target.
175        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
176        pub fs: ::std::option::Option<::std::string::String>,
177        ///Assign the request to a custom stats group.
178        #[serde(
179            rename = "_group",
180            default,
181            skip_serializing_if = "::std::option::Option::is_none"
182        )]
183        pub group: ::std::option::Option<::std::string::String>,
184        ///Backend command options encoded as a JSON string.
185        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
186        pub opt: ::std::option::Option<::std::string::String>,
187    }
188
189    impl ::std::convert::From<&BackendCommandRequest> for BackendCommandRequest {
190        fn from(value: &BackendCommandRequest) -> Self {
191            value.clone()
192        }
193    }
194
195    impl ::std::default::Default for BackendCommandRequest {
196        fn default() -> Self {
197            Self {
198                arg: Default::default(),
199                async_: Default::default(),
200                command: Default::default(),
201                fs: Default::default(),
202                group: Default::default(),
203                opt: Default::default(),
204            }
205        }
206    }
207
208    ///`BackendCommandResponse`
209    ///
210    /// <details><summary>JSON schema</summary>
211    ///
212    /// ```json
213    ///{
214    ///  "type": "object",
215    ///  "properties": {
216    ///    "result": {
217    ///      "description": "Backend command result payload"
218    ///    }
219    ///  },
220    ///  "additionalProperties": true
221    ///}
222    /// ```
223    /// </details>
224    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
225    pub struct BackendCommandResponse {
226        ///Backend command result payload
227        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
228        pub result: ::std::option::Option<::serde_json::Value>,
229    }
230
231    impl ::std::convert::From<&BackendCommandResponse> for BackendCommandResponse {
232        fn from(value: &BackendCommandResponse) -> Self {
233            value.clone()
234        }
235    }
236
237    impl ::std::default::Default for BackendCommandResponse {
238        fn default() -> Self {
239            Self {
240                result: Default::default(),
241            }
242        }
243    }
244
245    ///`CacheExpirePrefer`
246    ///
247    /// <details><summary>JSON schema</summary>
248    ///
249    /// ```json
250    ///{
251    ///  "type": "string",
252    ///  "enum": [
253    ///    "respond-async"
254    ///  ]
255    ///}
256    /// ```
257    /// </details>
258    #[derive(
259        :: serde :: Deserialize,
260        :: serde :: Serialize,
261        Clone,
262        Copy,
263        Debug,
264        Eq,
265        Hash,
266        Ord,
267        PartialEq,
268        PartialOrd,
269    )]
270    pub enum CacheExpirePrefer {
271        #[serde(rename = "respond-async")]
272        RespondAsync,
273    }
274
275    impl ::std::convert::From<&Self> for CacheExpirePrefer {
276        fn from(value: &CacheExpirePrefer) -> Self {
277            value.clone()
278        }
279    }
280
281    impl ::std::fmt::Display for CacheExpirePrefer {
282        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
283            match *self {
284                Self::RespondAsync => f.write_str("respond-async"),
285            }
286        }
287    }
288
289    impl ::std::str::FromStr for CacheExpirePrefer {
290        type Err = self::error::ConversionError;
291        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
292            match value {
293                "respond-async" => Ok(Self::RespondAsync),
294                _ => Err("invalid value".into()),
295            }
296        }
297    }
298
299    impl ::std::convert::TryFrom<&str> for CacheExpirePrefer {
300        type Error = self::error::ConversionError;
301        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
302            value.parse()
303        }
304    }
305
306    impl ::std::convert::TryFrom<&::std::string::String> for CacheExpirePrefer {
307        type Error = self::error::ConversionError;
308        fn try_from(
309            value: &::std::string::String,
310        ) -> ::std::result::Result<Self, self::error::ConversionError> {
311            value.parse()
312        }
313    }
314
315    impl ::std::convert::TryFrom<::std::string::String> for CacheExpirePrefer {
316        type Error = self::error::ConversionError;
317        fn try_from(
318            value: ::std::string::String,
319        ) -> ::std::result::Result<Self, self::error::ConversionError> {
320            value.parse()
321        }
322    }
323
324    ///`CacheExpireRequest`
325    ///
326    /// <details><summary>JSON schema</summary>
327    ///
328    /// ```json
329    ///{
330    ///  "type": "object",
331    ///  "properties": {
332    ///    "_async": {
333    ///      "description": "Run the command asynchronously. Returns a job id
334    /// immediately.",
335    ///      "type": "boolean"
336    ///    },
337    ///    "_group": {
338    ///      "description": "Assign the request to a custom stats group.",
339    ///      "type": "string"
340    ///    },
341    ///    "remote": {
342    ///      "description": "Remote path to expire from the cache, e.g.
343    /// `remote:path/to/dir`.",
344    ///      "type": "string"
345    ///    },
346    ///    "withData": {
347    ///      "description": "Set to true to drop cached chunk data along with
348    /// directory entries.",
349    ///      "type": "boolean"
350    ///    }
351    ///  }
352    ///}
353    /// ```
354    /// </details>
355    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
356    pub struct CacheExpireRequest {
357        ///Run the command asynchronously. Returns a job id immediately.
358        #[serde(
359            rename = "_async",
360            default,
361            skip_serializing_if = "::std::option::Option::is_none"
362        )]
363        pub async_: ::std::option::Option<bool>,
364        ///Assign the request to a custom stats group.
365        #[serde(
366            rename = "_group",
367            default,
368            skip_serializing_if = "::std::option::Option::is_none"
369        )]
370        pub group: ::std::option::Option<::std::string::String>,
371        ///Remote path to expire from the cache, e.g. `remote:path/to/dir`.
372        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
373        pub remote: ::std::option::Option<::std::string::String>,
374        ///Set to true to drop cached chunk data along with directory entries.
375        #[serde(
376            rename = "withData",
377            default,
378            skip_serializing_if = "::std::option::Option::is_none"
379        )]
380        pub with_data: ::std::option::Option<bool>,
381    }
382
383    impl ::std::convert::From<&CacheExpireRequest> for CacheExpireRequest {
384        fn from(value: &CacheExpireRequest) -> Self {
385            value.clone()
386        }
387    }
388
389    impl ::std::default::Default for CacheExpireRequest {
390        fn default() -> Self {
391            Self {
392                async_: Default::default(),
393                group: Default::default(),
394                remote: Default::default(),
395                with_data: Default::default(),
396            }
397        }
398    }
399
400    ///`CacheFetchPrefer`
401    ///
402    /// <details><summary>JSON schema</summary>
403    ///
404    /// ```json
405    ///{
406    ///  "type": "string",
407    ///  "enum": [
408    ///    "respond-async"
409    ///  ]
410    ///}
411    /// ```
412    /// </details>
413    #[derive(
414        :: serde :: Deserialize,
415        :: serde :: Serialize,
416        Clone,
417        Copy,
418        Debug,
419        Eq,
420        Hash,
421        Ord,
422        PartialEq,
423        PartialOrd,
424    )]
425    pub enum CacheFetchPrefer {
426        #[serde(rename = "respond-async")]
427        RespondAsync,
428    }
429
430    impl ::std::convert::From<&Self> for CacheFetchPrefer {
431        fn from(value: &CacheFetchPrefer) -> Self {
432            value.clone()
433        }
434    }
435
436    impl ::std::fmt::Display for CacheFetchPrefer {
437        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
438            match *self {
439                Self::RespondAsync => f.write_str("respond-async"),
440            }
441        }
442    }
443
444    impl ::std::str::FromStr for CacheFetchPrefer {
445        type Err = self::error::ConversionError;
446        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
447            match value {
448                "respond-async" => Ok(Self::RespondAsync),
449                _ => Err("invalid value".into()),
450            }
451        }
452    }
453
454    impl ::std::convert::TryFrom<&str> for CacheFetchPrefer {
455        type Error = self::error::ConversionError;
456        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
457            value.parse()
458        }
459    }
460
461    impl ::std::convert::TryFrom<&::std::string::String> for CacheFetchPrefer {
462        type Error = self::error::ConversionError;
463        fn try_from(
464            value: &::std::string::String,
465        ) -> ::std::result::Result<Self, self::error::ConversionError> {
466            value.parse()
467        }
468    }
469
470    impl ::std::convert::TryFrom<::std::string::String> for CacheFetchPrefer {
471        type Error = self::error::ConversionError;
472        fn try_from(
473            value: ::std::string::String,
474        ) -> ::std::result::Result<Self, self::error::ConversionError> {
475            value.parse()
476        }
477    }
478
479    ///`CacheFetchRequest`
480    ///
481    /// <details><summary>JSON schema</summary>
482    ///
483    /// ```json
484    ///{
485    ///  "type": "object",
486    ///  "properties": {
487    ///    "_async": {
488    ///      "description": "Run the command asynchronously. Returns a job id
489    /// immediately.",
490    ///      "type": "boolean"
491    ///    },
492    ///    "_group": {
493    ///      "description": "Assign the request to a custom stats group.",
494    ///      "type": "string"
495    ///    },
496    ///    "chunks": {
497    ///      "description": "Comma-separated chunk specifier list (e.g.
498    /// `0:10,25:30`) describing file pieces to prefetch.",
499    ///      "type": "string"
500    ///    }
501    ///  },
502    ///  "additionalProperties": true
503    ///}
504    /// ```
505    /// </details>
506    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
507    pub struct CacheFetchRequest {
508        ///Run the command asynchronously. Returns a job id immediately.
509        #[serde(
510            rename = "_async",
511            default,
512            skip_serializing_if = "::std::option::Option::is_none"
513        )]
514        pub async_: ::std::option::Option<bool>,
515        ///Comma-separated chunk specifier list (e.g. `0:10,25:30`) describing
516        /// file pieces to prefetch.
517        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
518        pub chunks: ::std::option::Option<::std::string::String>,
519        ///Assign the request to a custom stats group.
520        #[serde(
521            rename = "_group",
522            default,
523            skip_serializing_if = "::std::option::Option::is_none"
524        )]
525        pub group: ::std::option::Option<::std::string::String>,
526    }
527
528    impl ::std::convert::From<&CacheFetchRequest> for CacheFetchRequest {
529        fn from(value: &CacheFetchRequest) -> Self {
530            value.clone()
531        }
532    }
533
534    impl ::std::default::Default for CacheFetchRequest {
535        fn default() -> Self {
536            Self {
537                async_: Default::default(),
538                chunks: Default::default(),
539                group: Default::default(),
540            }
541        }
542    }
543
544    ///`CacheStatsPrefer`
545    ///
546    /// <details><summary>JSON schema</summary>
547    ///
548    /// ```json
549    ///{
550    ///  "type": "string",
551    ///  "enum": [
552    ///    "respond-async"
553    ///  ]
554    ///}
555    /// ```
556    /// </details>
557    #[derive(
558        :: serde :: Deserialize,
559        :: serde :: Serialize,
560        Clone,
561        Copy,
562        Debug,
563        Eq,
564        Hash,
565        Ord,
566        PartialEq,
567        PartialOrd,
568    )]
569    pub enum CacheStatsPrefer {
570        #[serde(rename = "respond-async")]
571        RespondAsync,
572    }
573
574    impl ::std::convert::From<&Self> for CacheStatsPrefer {
575        fn from(value: &CacheStatsPrefer) -> Self {
576            value.clone()
577        }
578    }
579
580    impl ::std::fmt::Display for CacheStatsPrefer {
581        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
582            match *self {
583                Self::RespondAsync => f.write_str("respond-async"),
584            }
585        }
586    }
587
588    impl ::std::str::FromStr for CacheStatsPrefer {
589        type Err = self::error::ConversionError;
590        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
591            match value {
592                "respond-async" => Ok(Self::RespondAsync),
593                _ => Err("invalid value".into()),
594            }
595        }
596    }
597
598    impl ::std::convert::TryFrom<&str> for CacheStatsPrefer {
599        type Error = self::error::ConversionError;
600        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
601            value.parse()
602        }
603    }
604
605    impl ::std::convert::TryFrom<&::std::string::String> for CacheStatsPrefer {
606        type Error = self::error::ConversionError;
607        fn try_from(
608            value: &::std::string::String,
609        ) -> ::std::result::Result<Self, self::error::ConversionError> {
610            value.parse()
611        }
612    }
613
614    impl ::std::convert::TryFrom<::std::string::String> for CacheStatsPrefer {
615        type Error = self::error::ConversionError;
616        fn try_from(
617            value: ::std::string::String,
618        ) -> ::std::result::Result<Self, self::error::ConversionError> {
619            value.parse()
620        }
621    }
622
623    ///`CacheStatsRequest`
624    ///
625    /// <details><summary>JSON schema</summary>
626    ///
627    /// ```json
628    ///{
629    ///  "type": "object",
630    ///  "properties": {
631    ///    "_async": {
632    ///      "description": "Run the command asynchronously. Returns a job id
633    /// immediately.",
634    ///      "type": "boolean"
635    ///    },
636    ///    "_group": {
637    ///      "description": "Assign the request to a custom stats group.",
638    ///      "type": "string"
639    ///    }
640    ///  }
641    ///}
642    /// ```
643    /// </details>
644    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
645    pub struct CacheStatsRequest {
646        ///Run the command asynchronously. Returns a job id immediately.
647        #[serde(
648            rename = "_async",
649            default,
650            skip_serializing_if = "::std::option::Option::is_none"
651        )]
652        pub async_: ::std::option::Option<bool>,
653        ///Assign the request to a custom stats group.
654        #[serde(
655            rename = "_group",
656            default,
657            skip_serializing_if = "::std::option::Option::is_none"
658        )]
659        pub group: ::std::option::Option<::std::string::String>,
660    }
661
662    impl ::std::convert::From<&CacheStatsRequest> for CacheStatsRequest {
663        fn from(value: &CacheStatsRequest) -> Self {
664            value.clone()
665        }
666    }
667
668    impl ::std::default::Default for CacheStatsRequest {
669        fn default() -> Self {
670            Self {
671                async_: Default::default(),
672                group: Default::default(),
673            }
674        }
675    }
676
677    ///`ConfigCreatePrefer`
678    ///
679    /// <details><summary>JSON schema</summary>
680    ///
681    /// ```json
682    ///{
683    ///  "type": "string",
684    ///  "enum": [
685    ///    "respond-async"
686    ///  ]
687    ///}
688    /// ```
689    /// </details>
690    #[derive(
691        :: serde :: Deserialize,
692        :: serde :: Serialize,
693        Clone,
694        Copy,
695        Debug,
696        Eq,
697        Hash,
698        Ord,
699        PartialEq,
700        PartialOrd,
701    )]
702    pub enum ConfigCreatePrefer {
703        #[serde(rename = "respond-async")]
704        RespondAsync,
705    }
706
707    impl ::std::convert::From<&Self> for ConfigCreatePrefer {
708        fn from(value: &ConfigCreatePrefer) -> Self {
709            value.clone()
710        }
711    }
712
713    impl ::std::fmt::Display for ConfigCreatePrefer {
714        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
715            match *self {
716                Self::RespondAsync => f.write_str("respond-async"),
717            }
718        }
719    }
720
721    impl ::std::str::FromStr for ConfigCreatePrefer {
722        type Err = self::error::ConversionError;
723        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
724            match value {
725                "respond-async" => Ok(Self::RespondAsync),
726                _ => Err("invalid value".into()),
727            }
728        }
729    }
730
731    impl ::std::convert::TryFrom<&str> for ConfigCreatePrefer {
732        type Error = self::error::ConversionError;
733        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
734            value.parse()
735        }
736    }
737
738    impl ::std::convert::TryFrom<&::std::string::String> for ConfigCreatePrefer {
739        type Error = self::error::ConversionError;
740        fn try_from(
741            value: &::std::string::String,
742        ) -> ::std::result::Result<Self, self::error::ConversionError> {
743            value.parse()
744        }
745    }
746
747    impl ::std::convert::TryFrom<::std::string::String> for ConfigCreatePrefer {
748        type Error = self::error::ConversionError;
749        fn try_from(
750            value: ::std::string::String,
751        ) -> ::std::result::Result<Self, self::error::ConversionError> {
752            value.parse()
753        }
754    }
755
756    ///`ConfigCreateRequest`
757    ///
758    /// <details><summary>JSON schema</summary>
759    ///
760    /// ```json
761    ///{
762    ///  "type": "object",
763    ///  "properties": {
764    ///    "_async": {
765    ///      "description": "Run the command asynchronously. Returns a job id
766    /// immediately.",
767    ///      "type": "boolean"
768    ///    },
769    ///    "_group": {
770    ///      "description": "Assign the request to a custom stats group.",
771    ///      "type": "string"
772    ///    },
773    ///    "name": {
774    ///      "description": "Name of the new remote configuration.",
775    ///      "type": "string"
776    ///    },
777    ///    "opt": {
778    ///      "description": "Optional JSON object controlling interactive
779    /// behaviour (e.g. `obscure`, `continue`).",
780    ///      "type": "string"
781    ///    },
782    ///    "parameters": {
783    ///      "description": "JSON object of configuration key/value pairs
784    /// required for the remote.",
785    ///      "type": "string"
786    ///    },
787    ///    "type": {
788    ///      "description": "Backend type identifier, such as `drive`, `s3`, or
789    /// `dropbox`.",
790    ///      "type": "string"
791    ///    }
792    ///  }
793    ///}
794    /// ```
795    /// </details>
796    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
797    pub struct ConfigCreateRequest {
798        ///Run the command asynchronously. Returns a job id immediately.
799        #[serde(
800            rename = "_async",
801            default,
802            skip_serializing_if = "::std::option::Option::is_none"
803        )]
804        pub async_: ::std::option::Option<bool>,
805        ///Assign the request to a custom stats group.
806        #[serde(
807            rename = "_group",
808            default,
809            skip_serializing_if = "::std::option::Option::is_none"
810        )]
811        pub group: ::std::option::Option<::std::string::String>,
812        ///Name of the new remote configuration.
813        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
814        pub name: ::std::option::Option<::std::string::String>,
815        ///Optional JSON object controlling interactive behaviour (e.g.
816        /// `obscure`, `continue`).
817        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
818        pub opt: ::std::option::Option<::std::string::String>,
819        ///JSON object of configuration key/value pairs required for the
820        /// remote.
821        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
822        pub parameters: ::std::option::Option<::std::string::String>,
823        ///Backend type identifier, such as `drive`, `s3`, or `dropbox`.
824        #[serde(
825            rename = "type",
826            default,
827            skip_serializing_if = "::std::option::Option::is_none"
828        )]
829        pub type_: ::std::option::Option<::std::string::String>,
830    }
831
832    impl ::std::convert::From<&ConfigCreateRequest> for ConfigCreateRequest {
833        fn from(value: &ConfigCreateRequest) -> Self {
834            value.clone()
835        }
836    }
837
838    impl ::std::default::Default for ConfigCreateRequest {
839        fn default() -> Self {
840            Self {
841                async_: Default::default(),
842                group: Default::default(),
843                name: Default::default(),
844                opt: Default::default(),
845                parameters: Default::default(),
846                type_: Default::default(),
847            }
848        }
849    }
850
851    ///`ConfigDeletePrefer`
852    ///
853    /// <details><summary>JSON schema</summary>
854    ///
855    /// ```json
856    ///{
857    ///  "type": "string",
858    ///  "enum": [
859    ///    "respond-async"
860    ///  ]
861    ///}
862    /// ```
863    /// </details>
864    #[derive(
865        :: serde :: Deserialize,
866        :: serde :: Serialize,
867        Clone,
868        Copy,
869        Debug,
870        Eq,
871        Hash,
872        Ord,
873        PartialEq,
874        PartialOrd,
875    )]
876    pub enum ConfigDeletePrefer {
877        #[serde(rename = "respond-async")]
878        RespondAsync,
879    }
880
881    impl ::std::convert::From<&Self> for ConfigDeletePrefer {
882        fn from(value: &ConfigDeletePrefer) -> Self {
883            value.clone()
884        }
885    }
886
887    impl ::std::fmt::Display for ConfigDeletePrefer {
888        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
889            match *self {
890                Self::RespondAsync => f.write_str("respond-async"),
891            }
892        }
893    }
894
895    impl ::std::str::FromStr for ConfigDeletePrefer {
896        type Err = self::error::ConversionError;
897        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
898            match value {
899                "respond-async" => Ok(Self::RespondAsync),
900                _ => Err("invalid value".into()),
901            }
902        }
903    }
904
905    impl ::std::convert::TryFrom<&str> for ConfigDeletePrefer {
906        type Error = self::error::ConversionError;
907        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
908            value.parse()
909        }
910    }
911
912    impl ::std::convert::TryFrom<&::std::string::String> for ConfigDeletePrefer {
913        type Error = self::error::ConversionError;
914        fn try_from(
915            value: &::std::string::String,
916        ) -> ::std::result::Result<Self, self::error::ConversionError> {
917            value.parse()
918        }
919    }
920
921    impl ::std::convert::TryFrom<::std::string::String> for ConfigDeletePrefer {
922        type Error = self::error::ConversionError;
923        fn try_from(
924            value: ::std::string::String,
925        ) -> ::std::result::Result<Self, self::error::ConversionError> {
926            value.parse()
927        }
928    }
929
930    ///`ConfigDeleteRequest`
931    ///
932    /// <details><summary>JSON schema</summary>
933    ///
934    /// ```json
935    ///{
936    ///  "type": "object",
937    ///  "properties": {
938    ///    "_async": {
939    ///      "description": "Run the command asynchronously. Returns a job id
940    /// immediately.",
941    ///      "type": "boolean"
942    ///    },
943    ///    "_group": {
944    ///      "description": "Assign the request to a custom stats group.",
945    ///      "type": "string"
946    ///    },
947    ///    "name": {
948    ///      "description": "Name of the remote configuration to delete.",
949    ///      "type": "string"
950    ///    }
951    ///  }
952    ///}
953    /// ```
954    /// </details>
955    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
956    pub struct ConfigDeleteRequest {
957        ///Run the command asynchronously. Returns a job id immediately.
958        #[serde(
959            rename = "_async",
960            default,
961            skip_serializing_if = "::std::option::Option::is_none"
962        )]
963        pub async_: ::std::option::Option<bool>,
964        ///Assign the request to a custom stats group.
965        #[serde(
966            rename = "_group",
967            default,
968            skip_serializing_if = "::std::option::Option::is_none"
969        )]
970        pub group: ::std::option::Option<::std::string::String>,
971        ///Name of the remote configuration to delete.
972        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
973        pub name: ::std::option::Option<::std::string::String>,
974    }
975
976    impl ::std::convert::From<&ConfigDeleteRequest> for ConfigDeleteRequest {
977        fn from(value: &ConfigDeleteRequest) -> Self {
978            value.clone()
979        }
980    }
981
982    impl ::std::default::Default for ConfigDeleteRequest {
983        fn default() -> Self {
984            Self {
985                async_: Default::default(),
986                group: Default::default(),
987                name: Default::default(),
988            }
989        }
990    }
991
992    ///`ConfigDumpPrefer`
993    ///
994    /// <details><summary>JSON schema</summary>
995    ///
996    /// ```json
997    ///{
998    ///  "type": "string",
999    ///  "enum": [
1000    ///    "respond-async"
1001    ///  ]
1002    ///}
1003    /// ```
1004    /// </details>
1005    #[derive(
1006        :: serde :: Deserialize,
1007        :: serde :: Serialize,
1008        Clone,
1009        Copy,
1010        Debug,
1011        Eq,
1012        Hash,
1013        Ord,
1014        PartialEq,
1015        PartialOrd,
1016    )]
1017    pub enum ConfigDumpPrefer {
1018        #[serde(rename = "respond-async")]
1019        RespondAsync,
1020    }
1021
1022    impl ::std::convert::From<&Self> for ConfigDumpPrefer {
1023        fn from(value: &ConfigDumpPrefer) -> Self {
1024            value.clone()
1025        }
1026    }
1027
1028    impl ::std::fmt::Display for ConfigDumpPrefer {
1029        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1030            match *self {
1031                Self::RespondAsync => f.write_str("respond-async"),
1032            }
1033        }
1034    }
1035
1036    impl ::std::str::FromStr for ConfigDumpPrefer {
1037        type Err = self::error::ConversionError;
1038        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1039            match value {
1040                "respond-async" => Ok(Self::RespondAsync),
1041                _ => Err("invalid value".into()),
1042            }
1043        }
1044    }
1045
1046    impl ::std::convert::TryFrom<&str> for ConfigDumpPrefer {
1047        type Error = self::error::ConversionError;
1048        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1049            value.parse()
1050        }
1051    }
1052
1053    impl ::std::convert::TryFrom<&::std::string::String> for ConfigDumpPrefer {
1054        type Error = self::error::ConversionError;
1055        fn try_from(
1056            value: &::std::string::String,
1057        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1058            value.parse()
1059        }
1060    }
1061
1062    impl ::std::convert::TryFrom<::std::string::String> for ConfigDumpPrefer {
1063        type Error = self::error::ConversionError;
1064        fn try_from(
1065            value: ::std::string::String,
1066        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1067            value.parse()
1068        }
1069    }
1070
1071    ///`ConfigDumpRequest`
1072    ///
1073    /// <details><summary>JSON schema</summary>
1074    ///
1075    /// ```json
1076    ///{
1077    ///  "type": "object",
1078    ///  "properties": {
1079    ///    "_async": {
1080    ///      "description": "Run the command asynchronously. Returns a job id
1081    /// immediately.",
1082    ///      "type": "boolean"
1083    ///    },
1084    ///    "_group": {
1085    ///      "description": "Assign the request to a custom stats group.",
1086    ///      "type": "string"
1087    ///    }
1088    ///  }
1089    ///}
1090    /// ```
1091    /// </details>
1092    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1093    pub struct ConfigDumpRequest {
1094        ///Run the command asynchronously. Returns a job id immediately.
1095        #[serde(
1096            rename = "_async",
1097            default,
1098            skip_serializing_if = "::std::option::Option::is_none"
1099        )]
1100        pub async_: ::std::option::Option<bool>,
1101        ///Assign the request to a custom stats group.
1102        #[serde(
1103            rename = "_group",
1104            default,
1105            skip_serializing_if = "::std::option::Option::is_none"
1106        )]
1107        pub group: ::std::option::Option<::std::string::String>,
1108    }
1109
1110    impl ::std::convert::From<&ConfigDumpRequest> for ConfigDumpRequest {
1111        fn from(value: &ConfigDumpRequest) -> Self {
1112            value.clone()
1113        }
1114    }
1115
1116    impl ::std::default::Default for ConfigDumpRequest {
1117        fn default() -> Self {
1118            Self {
1119                async_: Default::default(),
1120                group: Default::default(),
1121            }
1122        }
1123    }
1124
1125    ///`ConfigGetPrefer`
1126    ///
1127    /// <details><summary>JSON schema</summary>
1128    ///
1129    /// ```json
1130    ///{
1131    ///  "type": "string",
1132    ///  "enum": [
1133    ///    "respond-async"
1134    ///  ]
1135    ///}
1136    /// ```
1137    /// </details>
1138    #[derive(
1139        :: serde :: Deserialize,
1140        :: serde :: Serialize,
1141        Clone,
1142        Copy,
1143        Debug,
1144        Eq,
1145        Hash,
1146        Ord,
1147        PartialEq,
1148        PartialOrd,
1149    )]
1150    pub enum ConfigGetPrefer {
1151        #[serde(rename = "respond-async")]
1152        RespondAsync,
1153    }
1154
1155    impl ::std::convert::From<&Self> for ConfigGetPrefer {
1156        fn from(value: &ConfigGetPrefer) -> Self {
1157            value.clone()
1158        }
1159    }
1160
1161    impl ::std::fmt::Display for ConfigGetPrefer {
1162        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1163            match *self {
1164                Self::RespondAsync => f.write_str("respond-async"),
1165            }
1166        }
1167    }
1168
1169    impl ::std::str::FromStr for ConfigGetPrefer {
1170        type Err = self::error::ConversionError;
1171        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1172            match value {
1173                "respond-async" => Ok(Self::RespondAsync),
1174                _ => Err("invalid value".into()),
1175            }
1176        }
1177    }
1178
1179    impl ::std::convert::TryFrom<&str> for ConfigGetPrefer {
1180        type Error = self::error::ConversionError;
1181        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1182            value.parse()
1183        }
1184    }
1185
1186    impl ::std::convert::TryFrom<&::std::string::String> for ConfigGetPrefer {
1187        type Error = self::error::ConversionError;
1188        fn try_from(
1189            value: &::std::string::String,
1190        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1191            value.parse()
1192        }
1193    }
1194
1195    impl ::std::convert::TryFrom<::std::string::String> for ConfigGetPrefer {
1196        type Error = self::error::ConversionError;
1197        fn try_from(
1198            value: ::std::string::String,
1199        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1200            value.parse()
1201        }
1202    }
1203
1204    ///`ConfigGetRequest`
1205    ///
1206    /// <details><summary>JSON schema</summary>
1207    ///
1208    /// ```json
1209    ///{
1210    ///  "type": "object",
1211    ///  "properties": {
1212    ///    "_async": {
1213    ///      "description": "Run the command asynchronously. Returns a job id
1214    /// immediately.",
1215    ///      "type": "boolean"
1216    ///    },
1217    ///    "_group": {
1218    ///      "description": "Assign the request to a custom stats group.",
1219    ///      "type": "string"
1220    ///    },
1221    ///    "name": {
1222    ///      "description": "Name of the remote configuration to fetch.",
1223    ///      "type": "string"
1224    ///    }
1225    ///  }
1226    ///}
1227    /// ```
1228    /// </details>
1229    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1230    pub struct ConfigGetRequest {
1231        ///Run the command asynchronously. Returns a job id immediately.
1232        #[serde(
1233            rename = "_async",
1234            default,
1235            skip_serializing_if = "::std::option::Option::is_none"
1236        )]
1237        pub async_: ::std::option::Option<bool>,
1238        ///Assign the request to a custom stats group.
1239        #[serde(
1240            rename = "_group",
1241            default,
1242            skip_serializing_if = "::std::option::Option::is_none"
1243        )]
1244        pub group: ::std::option::Option<::std::string::String>,
1245        ///Name of the remote configuration to fetch.
1246        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1247        pub name: ::std::option::Option<::std::string::String>,
1248    }
1249
1250    impl ::std::convert::From<&ConfigGetRequest> for ConfigGetRequest {
1251        fn from(value: &ConfigGetRequest) -> Self {
1252            value.clone()
1253        }
1254    }
1255
1256    impl ::std::default::Default for ConfigGetRequest {
1257        fn default() -> Self {
1258            Self {
1259                async_: Default::default(),
1260                group: Default::default(),
1261                name: Default::default(),
1262            }
1263        }
1264    }
1265
1266    ///`ConfigGetResponse`
1267    ///
1268    /// <details><summary>JSON schema</summary>
1269    ///
1270    /// ```json
1271    ///{
1272    ///  "type": "object",
1273    ///  "required": [
1274    ///    "type"
1275    ///  ],
1276    ///  "properties": {
1277    ///    "type": {
1278    ///      "type": "string"
1279    ///    }
1280    ///  },
1281    ///  "additionalProperties": {
1282    ///    "type": "string"
1283    ///  }
1284    ///}
1285    /// ```
1286    /// </details>
1287    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1288    pub struct ConfigGetResponse {
1289        #[serde(rename = "type")]
1290        pub type_: ::std::string::String,
1291        #[serde(flatten)]
1292        pub extra: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
1293    }
1294
1295    impl ::std::convert::From<&ConfigGetResponse> for ConfigGetResponse {
1296        fn from(value: &ConfigGetResponse) -> Self {
1297            value.clone()
1298        }
1299    }
1300
1301    ///`ConfigListremotesPrefer`
1302    ///
1303    /// <details><summary>JSON schema</summary>
1304    ///
1305    /// ```json
1306    ///{
1307    ///  "type": "string",
1308    ///  "enum": [
1309    ///    "respond-async"
1310    ///  ]
1311    ///}
1312    /// ```
1313    /// </details>
1314    #[derive(
1315        :: serde :: Deserialize,
1316        :: serde :: Serialize,
1317        Clone,
1318        Copy,
1319        Debug,
1320        Eq,
1321        Hash,
1322        Ord,
1323        PartialEq,
1324        PartialOrd,
1325    )]
1326    pub enum ConfigListremotesPrefer {
1327        #[serde(rename = "respond-async")]
1328        RespondAsync,
1329    }
1330
1331    impl ::std::convert::From<&Self> for ConfigListremotesPrefer {
1332        fn from(value: &ConfigListremotesPrefer) -> Self {
1333            value.clone()
1334        }
1335    }
1336
1337    impl ::std::fmt::Display for ConfigListremotesPrefer {
1338        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1339            match *self {
1340                Self::RespondAsync => f.write_str("respond-async"),
1341            }
1342        }
1343    }
1344
1345    impl ::std::str::FromStr for ConfigListremotesPrefer {
1346        type Err = self::error::ConversionError;
1347        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1348            match value {
1349                "respond-async" => Ok(Self::RespondAsync),
1350                _ => Err("invalid value".into()),
1351            }
1352        }
1353    }
1354
1355    impl ::std::convert::TryFrom<&str> for ConfigListremotesPrefer {
1356        type Error = self::error::ConversionError;
1357        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1358            value.parse()
1359        }
1360    }
1361
1362    impl ::std::convert::TryFrom<&::std::string::String> for ConfigListremotesPrefer {
1363        type Error = self::error::ConversionError;
1364        fn try_from(
1365            value: &::std::string::String,
1366        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1367            value.parse()
1368        }
1369    }
1370
1371    impl ::std::convert::TryFrom<::std::string::String> for ConfigListremotesPrefer {
1372        type Error = self::error::ConversionError;
1373        fn try_from(
1374            value: ::std::string::String,
1375        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1376            value.parse()
1377        }
1378    }
1379
1380    ///`ConfigListremotesRequest`
1381    ///
1382    /// <details><summary>JSON schema</summary>
1383    ///
1384    /// ```json
1385    ///{
1386    ///  "type": "object",
1387    ///  "properties": {
1388    ///    "_async": {
1389    ///      "description": "Run the command asynchronously. Returns a job id
1390    /// immediately.",
1391    ///      "type": "boolean"
1392    ///    },
1393    ///    "_group": {
1394    ///      "description": "Assign the request to a custom stats group.",
1395    ///      "type": "string"
1396    ///    }
1397    ///  }
1398    ///}
1399    /// ```
1400    /// </details>
1401    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1402    pub struct ConfigListremotesRequest {
1403        ///Run the command asynchronously. Returns a job id immediately.
1404        #[serde(
1405            rename = "_async",
1406            default,
1407            skip_serializing_if = "::std::option::Option::is_none"
1408        )]
1409        pub async_: ::std::option::Option<bool>,
1410        ///Assign the request to a custom stats group.
1411        #[serde(
1412            rename = "_group",
1413            default,
1414            skip_serializing_if = "::std::option::Option::is_none"
1415        )]
1416        pub group: ::std::option::Option<::std::string::String>,
1417    }
1418
1419    impl ::std::convert::From<&ConfigListremotesRequest> for ConfigListremotesRequest {
1420        fn from(value: &ConfigListremotesRequest) -> Self {
1421            value.clone()
1422        }
1423    }
1424
1425    impl ::std::default::Default for ConfigListremotesRequest {
1426        fn default() -> Self {
1427            Self {
1428                async_: Default::default(),
1429                group: Default::default(),
1430            }
1431        }
1432    }
1433
1434    ///`ConfigListremotesResponse`
1435    ///
1436    /// <details><summary>JSON schema</summary>
1437    ///
1438    /// ```json
1439    ///{
1440    ///  "type": "object",
1441    ///  "required": [
1442    ///    "remotes"
1443    ///  ],
1444    ///  "properties": {
1445    ///    "remotes": {
1446    ///      "type": "array",
1447    ///      "items": {
1448    ///        "type": "string"
1449    ///      }
1450    ///    }
1451    ///  }
1452    ///}
1453    /// ```
1454    /// </details>
1455    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1456    pub struct ConfigListremotesResponse {
1457        pub remotes: ::std::vec::Vec<::std::string::String>,
1458    }
1459
1460    impl ::std::convert::From<&ConfigListremotesResponse> for ConfigListremotesResponse {
1461        fn from(value: &ConfigListremotesResponse) -> Self {
1462            value.clone()
1463        }
1464    }
1465
1466    ///`ConfigOauthstatusPrefer`
1467    ///
1468    /// <details><summary>JSON schema</summary>
1469    ///
1470    /// ```json
1471    ///{
1472    ///  "type": "string",
1473    ///  "enum": [
1474    ///    "respond-async"
1475    ///  ]
1476    ///}
1477    /// ```
1478    /// </details>
1479    #[derive(
1480        :: serde :: Deserialize,
1481        :: serde :: Serialize,
1482        Clone,
1483        Copy,
1484        Debug,
1485        Eq,
1486        Hash,
1487        Ord,
1488        PartialEq,
1489        PartialOrd,
1490    )]
1491    pub enum ConfigOauthstatusPrefer {
1492        #[serde(rename = "respond-async")]
1493        RespondAsync,
1494    }
1495
1496    impl ::std::convert::From<&Self> for ConfigOauthstatusPrefer {
1497        fn from(value: &ConfigOauthstatusPrefer) -> Self {
1498            value.clone()
1499        }
1500    }
1501
1502    impl ::std::fmt::Display for ConfigOauthstatusPrefer {
1503        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1504            match *self {
1505                Self::RespondAsync => f.write_str("respond-async"),
1506            }
1507        }
1508    }
1509
1510    impl ::std::str::FromStr for ConfigOauthstatusPrefer {
1511        type Err = self::error::ConversionError;
1512        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1513            match value {
1514                "respond-async" => Ok(Self::RespondAsync),
1515                _ => Err("invalid value".into()),
1516            }
1517        }
1518    }
1519
1520    impl ::std::convert::TryFrom<&str> for ConfigOauthstatusPrefer {
1521        type Error = self::error::ConversionError;
1522        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1523            value.parse()
1524        }
1525    }
1526
1527    impl ::std::convert::TryFrom<&::std::string::String> for ConfigOauthstatusPrefer {
1528        type Error = self::error::ConversionError;
1529        fn try_from(
1530            value: &::std::string::String,
1531        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1532            value.parse()
1533        }
1534    }
1535
1536    impl ::std::convert::TryFrom<::std::string::String> for ConfigOauthstatusPrefer {
1537        type Error = self::error::ConversionError;
1538        fn try_from(
1539            value: ::std::string::String,
1540        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1541            value.parse()
1542        }
1543    }
1544
1545    ///`ConfigOauthstatusRequest`
1546    ///
1547    /// <details><summary>JSON schema</summary>
1548    ///
1549    /// ```json
1550    ///{
1551    ///  "type": "object",
1552    ///  "properties": {
1553    ///    "_async": {
1554    ///      "description": "Run the command asynchronously. Returns a job id
1555    /// immediately.",
1556    ///      "type": "boolean"
1557    ///    },
1558    ///    "_group": {
1559    ///      "description": "Assign the request to a custom stats group.",
1560    ///      "type": "string"
1561    ///    }
1562    ///  }
1563    ///}
1564    /// ```
1565    /// </details>
1566    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1567    pub struct ConfigOauthstatusRequest {
1568        ///Run the command asynchronously. Returns a job id immediately.
1569        #[serde(
1570            rename = "_async",
1571            default,
1572            skip_serializing_if = "::std::option::Option::is_none"
1573        )]
1574        pub async_: ::std::option::Option<bool>,
1575        ///Assign the request to a custom stats group.
1576        #[serde(
1577            rename = "_group",
1578            default,
1579            skip_serializing_if = "::std::option::Option::is_none"
1580        )]
1581        pub group: ::std::option::Option<::std::string::String>,
1582    }
1583
1584    impl ::std::convert::From<&ConfigOauthstatusRequest> for ConfigOauthstatusRequest {
1585        fn from(value: &ConfigOauthstatusRequest) -> Self {
1586            value.clone()
1587        }
1588    }
1589
1590    impl ::std::default::Default for ConfigOauthstatusRequest {
1591        fn default() -> Self {
1592            Self {
1593                async_: Default::default(),
1594                group: Default::default(),
1595            }
1596        }
1597    }
1598
1599    ///`ConfigOauthstatusResponse`
1600    ///
1601    /// <details><summary>JSON schema</summary>
1602    ///
1603    /// ```json
1604    ///{
1605    ///  "type": "object",
1606    ///  "required": [
1607    ///    "status"
1608    ///  ],
1609    ///  "properties": {
1610    ///    "authUrl": {
1611    ///      "description": "Authorization URL to open in a browser. Present
1612    /// only when status is \"running\".",
1613    ///      "type": "string"
1614    ///    },
1615    ///    "status": {
1616    ///      "description": "Whether the OAuth authentication server is
1617    /// currently running.",
1618    ///      "type": "string",
1619    ///      "enum": [
1620    ///        "running",
1621    ///        "stopped"
1622    ///      ]
1623    ///    }
1624    ///  }
1625    ///}
1626    /// ```
1627    /// </details>
1628    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1629    pub struct ConfigOauthstatusResponse {
1630        ///Authorization URL to open in a browser. Present only when status is
1631        /// "running".
1632        #[serde(
1633            rename = "authUrl",
1634            default,
1635            skip_serializing_if = "::std::option::Option::is_none"
1636        )]
1637        pub auth_url: ::std::option::Option<::std::string::String>,
1638        ///Whether the OAuth authentication server is currently running.
1639        pub status: ConfigOauthstatusResponseStatus,
1640    }
1641
1642    impl ::std::convert::From<&ConfigOauthstatusResponse> for ConfigOauthstatusResponse {
1643        fn from(value: &ConfigOauthstatusResponse) -> Self {
1644            value.clone()
1645        }
1646    }
1647
1648    ///Whether the OAuth authentication server is currently running.
1649    ///
1650    /// <details><summary>JSON schema</summary>
1651    ///
1652    /// ```json
1653    ///{
1654    ///  "description": "Whether the OAuth authentication server is currently
1655    /// running.",
1656    ///  "type": "string",
1657    ///  "enum": [
1658    ///    "running",
1659    ///    "stopped"
1660    ///  ]
1661    ///}
1662    /// ```
1663    /// </details>
1664    #[derive(
1665        :: serde :: Deserialize,
1666        :: serde :: Serialize,
1667        Clone,
1668        Copy,
1669        Debug,
1670        Eq,
1671        Hash,
1672        Ord,
1673        PartialEq,
1674        PartialOrd,
1675    )]
1676    pub enum ConfigOauthstatusResponseStatus {
1677        #[serde(rename = "running")]
1678        Running,
1679        #[serde(rename = "stopped")]
1680        Stopped,
1681    }
1682
1683    impl ::std::convert::From<&Self> for ConfigOauthstatusResponseStatus {
1684        fn from(value: &ConfigOauthstatusResponseStatus) -> Self {
1685            value.clone()
1686        }
1687    }
1688
1689    impl ::std::fmt::Display for ConfigOauthstatusResponseStatus {
1690        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1691            match *self {
1692                Self::Running => f.write_str("running"),
1693                Self::Stopped => f.write_str("stopped"),
1694            }
1695        }
1696    }
1697
1698    impl ::std::str::FromStr for ConfigOauthstatusResponseStatus {
1699        type Err = self::error::ConversionError;
1700        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1701            match value {
1702                "running" => Ok(Self::Running),
1703                "stopped" => Ok(Self::Stopped),
1704                _ => Err("invalid value".into()),
1705            }
1706        }
1707    }
1708
1709    impl ::std::convert::TryFrom<&str> for ConfigOauthstatusResponseStatus {
1710        type Error = self::error::ConversionError;
1711        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1712            value.parse()
1713        }
1714    }
1715
1716    impl ::std::convert::TryFrom<&::std::string::String> for ConfigOauthstatusResponseStatus {
1717        type Error = self::error::ConversionError;
1718        fn try_from(
1719            value: &::std::string::String,
1720        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1721            value.parse()
1722        }
1723    }
1724
1725    impl ::std::convert::TryFrom<::std::string::String> for ConfigOauthstatusResponseStatus {
1726        type Error = self::error::ConversionError;
1727        fn try_from(
1728            value: ::std::string::String,
1729        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1730            value.parse()
1731        }
1732    }
1733
1734    ///`ConfigOauthstopPrefer`
1735    ///
1736    /// <details><summary>JSON schema</summary>
1737    ///
1738    /// ```json
1739    ///{
1740    ///  "type": "string",
1741    ///  "enum": [
1742    ///    "respond-async"
1743    ///  ]
1744    ///}
1745    /// ```
1746    /// </details>
1747    #[derive(
1748        :: serde :: Deserialize,
1749        :: serde :: Serialize,
1750        Clone,
1751        Copy,
1752        Debug,
1753        Eq,
1754        Hash,
1755        Ord,
1756        PartialEq,
1757        PartialOrd,
1758    )]
1759    pub enum ConfigOauthstopPrefer {
1760        #[serde(rename = "respond-async")]
1761        RespondAsync,
1762    }
1763
1764    impl ::std::convert::From<&Self> for ConfigOauthstopPrefer {
1765        fn from(value: &ConfigOauthstopPrefer) -> Self {
1766            value.clone()
1767        }
1768    }
1769
1770    impl ::std::fmt::Display for ConfigOauthstopPrefer {
1771        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1772            match *self {
1773                Self::RespondAsync => f.write_str("respond-async"),
1774            }
1775        }
1776    }
1777
1778    impl ::std::str::FromStr for ConfigOauthstopPrefer {
1779        type Err = self::error::ConversionError;
1780        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1781            match value {
1782                "respond-async" => Ok(Self::RespondAsync),
1783                _ => Err("invalid value".into()),
1784            }
1785        }
1786    }
1787
1788    impl ::std::convert::TryFrom<&str> for ConfigOauthstopPrefer {
1789        type Error = self::error::ConversionError;
1790        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1791            value.parse()
1792        }
1793    }
1794
1795    impl ::std::convert::TryFrom<&::std::string::String> for ConfigOauthstopPrefer {
1796        type Error = self::error::ConversionError;
1797        fn try_from(
1798            value: &::std::string::String,
1799        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1800            value.parse()
1801        }
1802    }
1803
1804    impl ::std::convert::TryFrom<::std::string::String> for ConfigOauthstopPrefer {
1805        type Error = self::error::ConversionError;
1806        fn try_from(
1807            value: ::std::string::String,
1808        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1809            value.parse()
1810        }
1811    }
1812
1813    ///`ConfigOauthstopRequest`
1814    ///
1815    /// <details><summary>JSON schema</summary>
1816    ///
1817    /// ```json
1818    ///{
1819    ///  "type": "object",
1820    ///  "properties": {
1821    ///    "_async": {
1822    ///      "description": "Run the command asynchronously. Returns a job id
1823    /// immediately.",
1824    ///      "type": "boolean"
1825    ///    },
1826    ///    "_group": {
1827    ///      "description": "Assign the request to a custom stats group.",
1828    ///      "type": "string"
1829    ///    }
1830    ///  }
1831    ///}
1832    /// ```
1833    /// </details>
1834    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1835    pub struct ConfigOauthstopRequest {
1836        ///Run the command asynchronously. Returns a job id immediately.
1837        #[serde(
1838            rename = "_async",
1839            default,
1840            skip_serializing_if = "::std::option::Option::is_none"
1841        )]
1842        pub async_: ::std::option::Option<bool>,
1843        ///Assign the request to a custom stats group.
1844        #[serde(
1845            rename = "_group",
1846            default,
1847            skip_serializing_if = "::std::option::Option::is_none"
1848        )]
1849        pub group: ::std::option::Option<::std::string::String>,
1850    }
1851
1852    impl ::std::convert::From<&ConfigOauthstopRequest> for ConfigOauthstopRequest {
1853        fn from(value: &ConfigOauthstopRequest) -> Self {
1854            value.clone()
1855        }
1856    }
1857
1858    impl ::std::default::Default for ConfigOauthstopRequest {
1859        fn default() -> Self {
1860            Self {
1861                async_: Default::default(),
1862                group: Default::default(),
1863            }
1864        }
1865    }
1866
1867    ///`ConfigPasswordPrefer`
1868    ///
1869    /// <details><summary>JSON schema</summary>
1870    ///
1871    /// ```json
1872    ///{
1873    ///  "type": "string",
1874    ///  "enum": [
1875    ///    "respond-async"
1876    ///  ]
1877    ///}
1878    /// ```
1879    /// </details>
1880    #[derive(
1881        :: serde :: Deserialize,
1882        :: serde :: Serialize,
1883        Clone,
1884        Copy,
1885        Debug,
1886        Eq,
1887        Hash,
1888        Ord,
1889        PartialEq,
1890        PartialOrd,
1891    )]
1892    pub enum ConfigPasswordPrefer {
1893        #[serde(rename = "respond-async")]
1894        RespondAsync,
1895    }
1896
1897    impl ::std::convert::From<&Self> for ConfigPasswordPrefer {
1898        fn from(value: &ConfigPasswordPrefer) -> Self {
1899            value.clone()
1900        }
1901    }
1902
1903    impl ::std::fmt::Display for ConfigPasswordPrefer {
1904        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1905            match *self {
1906                Self::RespondAsync => f.write_str("respond-async"),
1907            }
1908        }
1909    }
1910
1911    impl ::std::str::FromStr for ConfigPasswordPrefer {
1912        type Err = self::error::ConversionError;
1913        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1914            match value {
1915                "respond-async" => Ok(Self::RespondAsync),
1916                _ => Err("invalid value".into()),
1917            }
1918        }
1919    }
1920
1921    impl ::std::convert::TryFrom<&str> for ConfigPasswordPrefer {
1922        type Error = self::error::ConversionError;
1923        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1924            value.parse()
1925        }
1926    }
1927
1928    impl ::std::convert::TryFrom<&::std::string::String> for ConfigPasswordPrefer {
1929        type Error = self::error::ConversionError;
1930        fn try_from(
1931            value: &::std::string::String,
1932        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1933            value.parse()
1934        }
1935    }
1936
1937    impl ::std::convert::TryFrom<::std::string::String> for ConfigPasswordPrefer {
1938        type Error = self::error::ConversionError;
1939        fn try_from(
1940            value: ::std::string::String,
1941        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1942            value.parse()
1943        }
1944    }
1945
1946    ///`ConfigPasswordRequest`
1947    ///
1948    /// <details><summary>JSON schema</summary>
1949    ///
1950    /// ```json
1951    ///{
1952    ///  "type": "object",
1953    ///  "properties": {
1954    ///    "_async": {
1955    ///      "description": "Run the command asynchronously. Returns a job id
1956    /// immediately.",
1957    ///      "type": "boolean"
1958    ///    },
1959    ///    "_group": {
1960    ///      "description": "Assign the request to a custom stats group.",
1961    ///      "type": "string"
1962    ///    },
1963    ///    "name": {
1964    ///      "description": "Name of the remote whose secrets should be
1965    /// updated.",
1966    ///      "type": "string"
1967    ///    },
1968    ///    "parameters": {
1969    ///      "description": "JSON object of password answers, typically
1970    /// including `pass`.",
1971    ///      "type": "string"
1972    ///    }
1973    ///  }
1974    ///}
1975    /// ```
1976    /// </details>
1977    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1978    pub struct ConfigPasswordRequest {
1979        ///Run the command asynchronously. Returns a job id immediately.
1980        #[serde(
1981            rename = "_async",
1982            default,
1983            skip_serializing_if = "::std::option::Option::is_none"
1984        )]
1985        pub async_: ::std::option::Option<bool>,
1986        ///Assign the request to a custom stats group.
1987        #[serde(
1988            rename = "_group",
1989            default,
1990            skip_serializing_if = "::std::option::Option::is_none"
1991        )]
1992        pub group: ::std::option::Option<::std::string::String>,
1993        ///Name of the remote whose secrets should be updated.
1994        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1995        pub name: ::std::option::Option<::std::string::String>,
1996        ///JSON object of password answers, typically including `pass`.
1997        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1998        pub parameters: ::std::option::Option<::std::string::String>,
1999    }
2000
2001    impl ::std::convert::From<&ConfigPasswordRequest> for ConfigPasswordRequest {
2002        fn from(value: &ConfigPasswordRequest) -> Self {
2003            value.clone()
2004        }
2005    }
2006
2007    impl ::std::default::Default for ConfigPasswordRequest {
2008        fn default() -> Self {
2009            Self {
2010                async_: Default::default(),
2011                group: Default::default(),
2012                name: Default::default(),
2013                parameters: Default::default(),
2014            }
2015        }
2016    }
2017
2018    ///`ConfigPathsPrefer`
2019    ///
2020    /// <details><summary>JSON schema</summary>
2021    ///
2022    /// ```json
2023    ///{
2024    ///  "type": "string",
2025    ///  "enum": [
2026    ///    "respond-async"
2027    ///  ]
2028    ///}
2029    /// ```
2030    /// </details>
2031    #[derive(
2032        :: serde :: Deserialize,
2033        :: serde :: Serialize,
2034        Clone,
2035        Copy,
2036        Debug,
2037        Eq,
2038        Hash,
2039        Ord,
2040        PartialEq,
2041        PartialOrd,
2042    )]
2043    pub enum ConfigPathsPrefer {
2044        #[serde(rename = "respond-async")]
2045        RespondAsync,
2046    }
2047
2048    impl ::std::convert::From<&Self> for ConfigPathsPrefer {
2049        fn from(value: &ConfigPathsPrefer) -> Self {
2050            value.clone()
2051        }
2052    }
2053
2054    impl ::std::fmt::Display for ConfigPathsPrefer {
2055        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2056            match *self {
2057                Self::RespondAsync => f.write_str("respond-async"),
2058            }
2059        }
2060    }
2061
2062    impl ::std::str::FromStr for ConfigPathsPrefer {
2063        type Err = self::error::ConversionError;
2064        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2065            match value {
2066                "respond-async" => Ok(Self::RespondAsync),
2067                _ => Err("invalid value".into()),
2068            }
2069        }
2070    }
2071
2072    impl ::std::convert::TryFrom<&str> for ConfigPathsPrefer {
2073        type Error = self::error::ConversionError;
2074        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2075            value.parse()
2076        }
2077    }
2078
2079    impl ::std::convert::TryFrom<&::std::string::String> for ConfigPathsPrefer {
2080        type Error = self::error::ConversionError;
2081        fn try_from(
2082            value: &::std::string::String,
2083        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2084            value.parse()
2085        }
2086    }
2087
2088    impl ::std::convert::TryFrom<::std::string::String> for ConfigPathsPrefer {
2089        type Error = self::error::ConversionError;
2090        fn try_from(
2091            value: ::std::string::String,
2092        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2093            value.parse()
2094        }
2095    }
2096
2097    ///`ConfigPathsRequest`
2098    ///
2099    /// <details><summary>JSON schema</summary>
2100    ///
2101    /// ```json
2102    ///{
2103    ///  "type": "object",
2104    ///  "properties": {
2105    ///    "_async": {
2106    ///      "description": "Run the command asynchronously. Returns a job id
2107    /// immediately.",
2108    ///      "type": "boolean"
2109    ///    },
2110    ///    "_group": {
2111    ///      "description": "Assign the request to a custom stats group.",
2112    ///      "type": "string"
2113    ///    }
2114    ///  }
2115    ///}
2116    /// ```
2117    /// </details>
2118    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2119    pub struct ConfigPathsRequest {
2120        ///Run the command asynchronously. Returns a job id immediately.
2121        #[serde(
2122            rename = "_async",
2123            default,
2124            skip_serializing_if = "::std::option::Option::is_none"
2125        )]
2126        pub async_: ::std::option::Option<bool>,
2127        ///Assign the request to a custom stats group.
2128        #[serde(
2129            rename = "_group",
2130            default,
2131            skip_serializing_if = "::std::option::Option::is_none"
2132        )]
2133        pub group: ::std::option::Option<::std::string::String>,
2134    }
2135
2136    impl ::std::convert::From<&ConfigPathsRequest> for ConfigPathsRequest {
2137        fn from(value: &ConfigPathsRequest) -> Self {
2138            value.clone()
2139        }
2140    }
2141
2142    impl ::std::default::Default for ConfigPathsRequest {
2143        fn default() -> Self {
2144            Self {
2145                async_: Default::default(),
2146                group: Default::default(),
2147            }
2148        }
2149    }
2150
2151    ///`ConfigPathsResponse`
2152    ///
2153    /// <details><summary>JSON schema</summary>
2154    ///
2155    /// ```json
2156    ///{
2157    ///  "type": "object",
2158    ///  "required": [
2159    ///    "cache",
2160    ///    "config",
2161    ///    "temp"
2162    ///  ],
2163    ///  "properties": {
2164    ///    "cache": {
2165    ///      "type": "string"
2166    ///    },
2167    ///    "config": {
2168    ///      "type": "string"
2169    ///    },
2170    ///    "temp": {
2171    ///      "type": "string"
2172    ///    }
2173    ///  }
2174    ///}
2175    /// ```
2176    /// </details>
2177    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2178    pub struct ConfigPathsResponse {
2179        pub cache: ::std::string::String,
2180        pub config: ::std::string::String,
2181        pub temp: ::std::string::String,
2182    }
2183
2184    impl ::std::convert::From<&ConfigPathsResponse> for ConfigPathsResponse {
2185        fn from(value: &ConfigPathsResponse) -> Self {
2186            value.clone()
2187        }
2188    }
2189
2190    ///`ConfigProvider`
2191    ///
2192    /// <details><summary>JSON schema</summary>
2193    ///
2194    /// ```json
2195    ///{
2196    ///  "type": "object",
2197    ///  "required": [
2198    ///    "Description",
2199    ///    "Name",
2200    ///    "Options",
2201    ///    "Prefix"
2202    ///  ],
2203    ///  "properties": {
2204    ///    "Aliases": {
2205    ///      "type": [
2206    ///        "array",
2207    ///        "null"
2208    ///      ],
2209    ///      "items": {
2210    ///        "type": "string"
2211    ///      }
2212    ///    },
2213    ///    "CommandHelp": {
2214    ///      "type": [
2215    ///        "array",
2216    ///        "null"
2217    ///      ],
2218    ///      "items": {
2219    ///        "$ref": "#/components/schemas/ConfigProviderCommandHelp"
2220    ///      }
2221    ///    },
2222    ///    "Description": {
2223    ///      "type": "string"
2224    ///    },
2225    ///    "Hide": {
2226    ///      "type": "boolean"
2227    ///    },
2228    ///    "MetadataInfo": {
2229    ///      "$ref": "#/components/schemas/ConfigProviderMetadataInfo"
2230    ///    },
2231    ///    "Name": {
2232    ///      "type": "string"
2233    ///    },
2234    ///    "Options": {
2235    ///      "type": "array",
2236    ///      "items": {
2237    ///        "$ref": "#/components/schemas/ConfigProviderOption"
2238    ///      }
2239    ///    },
2240    ///    "Prefix": {
2241    ///      "type": "string"
2242    ///    }
2243    ///  },
2244    ///  "additionalProperties": true
2245    ///}
2246    /// ```
2247    /// </details>
2248    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2249    pub struct ConfigProvider {
2250        #[serde(
2251            rename = "Aliases",
2252            default,
2253            skip_serializing_if = "::std::option::Option::is_none"
2254        )]
2255        pub aliases: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
2256        #[serde(
2257            rename = "CommandHelp",
2258            default,
2259            skip_serializing_if = "::std::option::Option::is_none"
2260        )]
2261        pub command_help: ::std::option::Option<::std::vec::Vec<ConfigProviderCommandHelp>>,
2262        #[serde(rename = "Description")]
2263        pub description: ::std::string::String,
2264        #[serde(
2265            rename = "Hide",
2266            default,
2267            skip_serializing_if = "::std::option::Option::is_none"
2268        )]
2269        pub hide: ::std::option::Option<bool>,
2270        #[serde(
2271            rename = "MetadataInfo",
2272            default,
2273            skip_serializing_if = "::std::option::Option::is_none"
2274        )]
2275        pub metadata_info: ::std::option::Option<ConfigProviderMetadataInfo>,
2276        #[serde(rename = "Name")]
2277        pub name: ::std::string::String,
2278        #[serde(rename = "Options")]
2279        pub options: ::std::vec::Vec<ConfigProviderOption>,
2280        #[serde(rename = "Prefix")]
2281        pub prefix: ::std::string::String,
2282    }
2283
2284    impl ::std::convert::From<&ConfigProvider> for ConfigProvider {
2285        fn from(value: &ConfigProvider) -> Self {
2286            value.clone()
2287        }
2288    }
2289
2290    ///`ConfigProviderCommandHelp`
2291    ///
2292    /// <details><summary>JSON schema</summary>
2293    ///
2294    /// ```json
2295    ///{
2296    ///  "type": "object",
2297    ///  "properties": {
2298    ///    "Long": {
2299    ///      "type": "string"
2300    ///    },
2301    ///    "Name": {
2302    ///      "type": "string"
2303    ///    },
2304    ///    "Opts": {
2305    ///      "type": [
2306    ///        "object",
2307    ///        "null"
2308    ///      ],
2309    ///      "additionalProperties": true
2310    ///    },
2311    ///    "Short": {
2312    ///      "type": "string"
2313    ///    }
2314    ///  },
2315    ///  "additionalProperties": true
2316    ///}
2317    /// ```
2318    /// </details>
2319    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2320    pub struct ConfigProviderCommandHelp {
2321        #[serde(
2322            rename = "Long",
2323            default,
2324            skip_serializing_if = "::std::option::Option::is_none"
2325        )]
2326        pub long: ::std::option::Option<::std::string::String>,
2327        #[serde(
2328            rename = "Name",
2329            default,
2330            skip_serializing_if = "::std::option::Option::is_none"
2331        )]
2332        pub name: ::std::option::Option<::std::string::String>,
2333        #[serde(
2334            rename = "Opts",
2335            default,
2336            skip_serializing_if = "::std::option::Option::is_none"
2337        )]
2338        pub opts:
2339            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
2340        #[serde(
2341            rename = "Short",
2342            default,
2343            skip_serializing_if = "::std::option::Option::is_none"
2344        )]
2345        pub short: ::std::option::Option<::std::string::String>,
2346    }
2347
2348    impl ::std::convert::From<&ConfigProviderCommandHelp> for ConfigProviderCommandHelp {
2349        fn from(value: &ConfigProviderCommandHelp) -> Self {
2350            value.clone()
2351        }
2352    }
2353
2354    impl ::std::default::Default for ConfigProviderCommandHelp {
2355        fn default() -> Self {
2356            Self {
2357                long: Default::default(),
2358                name: Default::default(),
2359                opts: Default::default(),
2360                short: Default::default(),
2361            }
2362        }
2363    }
2364
2365    ///`ConfigProviderMetadataInfo`
2366    ///
2367    /// <details><summary>JSON schema</summary>
2368    ///
2369    /// ```json
2370    ///{
2371    ///  "type": "object",
2372    ///  "properties": {
2373    ///    "Help": {
2374    ///      "type": "string"
2375    ///    },
2376    ///    "System": {
2377    ///      "type": [
2378    ///        "object",
2379    ///        "null"
2380    ///      ],
2381    ///      "additionalProperties": {
2382    ///        "$ref": "#/components/schemas/ConfigProviderMetadataSystemEntry"
2383    ///      }
2384    ///    }
2385    ///  },
2386    ///  "additionalProperties": true
2387    ///}
2388    /// ```
2389    /// </details>
2390    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2391    pub struct ConfigProviderMetadataInfo {
2392        #[serde(
2393            rename = "Help",
2394            default,
2395            skip_serializing_if = "::std::option::Option::is_none"
2396        )]
2397        pub help: ::std::option::Option<::std::string::String>,
2398        #[serde(
2399            rename = "System",
2400            default,
2401            skip_serializing_if = "::std::option::Option::is_none"
2402        )]
2403        pub system: ::std::option::Option<
2404            ::std::collections::HashMap<::std::string::String, ConfigProviderMetadataSystemEntry>,
2405        >,
2406    }
2407
2408    impl ::std::convert::From<&ConfigProviderMetadataInfo> for ConfigProviderMetadataInfo {
2409        fn from(value: &ConfigProviderMetadataInfo) -> Self {
2410            value.clone()
2411        }
2412    }
2413
2414    impl ::std::default::Default for ConfigProviderMetadataInfo {
2415        fn default() -> Self {
2416            Self {
2417                help: Default::default(),
2418                system: Default::default(),
2419            }
2420        }
2421    }
2422
2423    ///`ConfigProviderMetadataSystemEntry`
2424    ///
2425    /// <details><summary>JSON schema</summary>
2426    ///
2427    /// ```json
2428    ///{
2429    ///  "type": "object",
2430    ///  "properties": {
2431    ///    "Example": {
2432    ///      "type": "string"
2433    ///    },
2434    ///    "Help": {
2435    ///      "type": "string"
2436    ///    },
2437    ///    "ReadOnly": {
2438    ///      "type": "boolean"
2439    ///    },
2440    ///    "Type": {
2441    ///      "type": "string"
2442    ///    }
2443    ///  },
2444    ///  "additionalProperties": true
2445    ///}
2446    /// ```
2447    /// </details>
2448    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2449    pub struct ConfigProviderMetadataSystemEntry {
2450        #[serde(
2451            rename = "Example",
2452            default,
2453            skip_serializing_if = "::std::option::Option::is_none"
2454        )]
2455        pub example: ::std::option::Option<::std::string::String>,
2456        #[serde(
2457            rename = "Help",
2458            default,
2459            skip_serializing_if = "::std::option::Option::is_none"
2460        )]
2461        pub help: ::std::option::Option<::std::string::String>,
2462        #[serde(
2463            rename = "ReadOnly",
2464            default,
2465            skip_serializing_if = "::std::option::Option::is_none"
2466        )]
2467        pub read_only: ::std::option::Option<bool>,
2468        #[serde(
2469            rename = "Type",
2470            default,
2471            skip_serializing_if = "::std::option::Option::is_none"
2472        )]
2473        pub type_: ::std::option::Option<::std::string::String>,
2474    }
2475
2476    impl ::std::convert::From<&ConfigProviderMetadataSystemEntry>
2477        for ConfigProviderMetadataSystemEntry
2478    {
2479        fn from(value: &ConfigProviderMetadataSystemEntry) -> Self {
2480            value.clone()
2481        }
2482    }
2483
2484    impl ::std::default::Default for ConfigProviderMetadataSystemEntry {
2485        fn default() -> Self {
2486            Self {
2487                example: Default::default(),
2488                help: Default::default(),
2489                read_only: Default::default(),
2490                type_: Default::default(),
2491            }
2492        }
2493    }
2494
2495    ///`ConfigProviderOption`
2496    ///
2497    /// <details><summary>JSON schema</summary>
2498    ///
2499    /// ```json
2500    ///{
2501    ///  "type": "object",
2502    ///  "required": [
2503    ///    "Advanced",
2504    ///    "Default",
2505    ///    "DefaultStr",
2506    ///    "Exclusive",
2507    ///    "FieldName",
2508    ///    "Help",
2509    ///    "Hide",
2510    ///    "IsPassword",
2511    ///    "Name",
2512    ///    "NoPrefix",
2513    ///    "Required",
2514    ///    "Sensitive",
2515    ///    "Type",
2516    ///    "Value",
2517    ///    "ValueStr"
2518    ///  ],
2519    ///  "properties": {
2520    ///    "Advanced": {
2521    ///      "type": "boolean"
2522    ///    },
2523    ///    "Default": {
2524    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
2525    ///    },
2526    ///    "DefaultStr": {
2527    ///      "type": "string"
2528    ///    },
2529    ///    "Examples": {
2530    ///      "type": "array",
2531    ///      "items": {
2532    ///        "$ref": "#/components/schemas/ConfigProviderOptionExample"
2533    ///      }
2534    ///    },
2535    ///    "Exclusive": {
2536    ///      "type": "boolean"
2537    ///    },
2538    ///    "FieldName": {
2539    ///      "type": "string"
2540    ///    },
2541    ///    "Help": {
2542    ///      "type": "string"
2543    ///    },
2544    ///    "Hide": {
2545    ///      "type": "number"
2546    ///    },
2547    ///    "IsPassword": {
2548    ///      "type": "boolean"
2549    ///    },
2550    ///    "Name": {
2551    ///      "type": "string"
2552    ///    },
2553    ///    "NoPrefix": {
2554    ///      "type": "boolean"
2555    ///    },
2556    ///    "Provider": {
2557    ///      "type": "string"
2558    ///    },
2559    ///    "Required": {
2560    ///      "type": "boolean"
2561    ///    },
2562    ///    "Sensitive": {
2563    ///      "type": "boolean"
2564    ///    },
2565    ///    "ShortOpt": {
2566    ///      "type": "string"
2567    ///    },
2568    ///    "Type": {
2569    ///      "$ref": "#/components/schemas/ConfigProviderOptionType"
2570    ///    },
2571    ///    "Value": {
2572    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
2573    ///    },
2574    ///    "ValueStr": {
2575    ///      "type": "string"
2576    ///    }
2577    ///  },
2578    ///  "additionalProperties": true
2579    ///}
2580    /// ```
2581    /// </details>
2582    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2583    pub struct ConfigProviderOption {
2584        #[serde(rename = "Advanced")]
2585        pub advanced: bool,
2586        #[serde(rename = "Default")]
2587        pub default: ConfigProviderOptionAny,
2588        #[serde(rename = "DefaultStr")]
2589        pub default_str: ::std::string::String,
2590        #[serde(
2591            rename = "Examples",
2592            default,
2593            skip_serializing_if = "::std::vec::Vec::is_empty"
2594        )]
2595        pub examples: ::std::vec::Vec<ConfigProviderOptionExample>,
2596        #[serde(rename = "Exclusive")]
2597        pub exclusive: bool,
2598        #[serde(rename = "FieldName")]
2599        pub field_name: ::std::string::String,
2600        #[serde(rename = "Help")]
2601        pub help: ::std::string::String,
2602        #[serde(rename = "Hide")]
2603        pub hide: f64,
2604        #[serde(rename = "IsPassword")]
2605        pub is_password: bool,
2606        #[serde(rename = "Name")]
2607        pub name: ::std::string::String,
2608        #[serde(rename = "NoPrefix")]
2609        pub no_prefix: bool,
2610        #[serde(
2611            rename = "Provider",
2612            default,
2613            skip_serializing_if = "::std::option::Option::is_none"
2614        )]
2615        pub provider: ::std::option::Option<::std::string::String>,
2616        #[serde(rename = "Required")]
2617        pub required: bool,
2618        #[serde(rename = "Sensitive")]
2619        pub sensitive: bool,
2620        #[serde(
2621            rename = "ShortOpt",
2622            default,
2623            skip_serializing_if = "::std::option::Option::is_none"
2624        )]
2625        pub short_opt: ::std::option::Option<::std::string::String>,
2626        #[serde(rename = "Type")]
2627        pub type_: ConfigProviderOptionType,
2628        #[serde(rename = "Value")]
2629        pub value: ConfigProviderOptionAny,
2630        #[serde(rename = "ValueStr")]
2631        pub value_str: ::std::string::String,
2632    }
2633
2634    impl ::std::convert::From<&ConfigProviderOption> for ConfigProviderOption {
2635        fn from(value: &ConfigProviderOption) -> Self {
2636            value.clone()
2637        }
2638    }
2639
2640    ///`ConfigProviderOptionAny`
2641    ///
2642    /// <details><summary>JSON schema</summary>
2643    ///
2644    /// ```json
2645    ///{}
2646    /// ```
2647    /// </details>
2648    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2649    #[serde(transparent)]
2650    pub struct ConfigProviderOptionAny(pub ::serde_json::Value);
2651    impl ::std::ops::Deref for ConfigProviderOptionAny {
2652        type Target = ::serde_json::Value;
2653        fn deref(&self) -> &::serde_json::Value {
2654            &self.0
2655        }
2656    }
2657
2658    impl ::std::convert::From<ConfigProviderOptionAny> for ::serde_json::Value {
2659        fn from(value: ConfigProviderOptionAny) -> Self {
2660            value.0
2661        }
2662    }
2663
2664    impl ::std::convert::From<&ConfigProviderOptionAny> for ConfigProviderOptionAny {
2665        fn from(value: &ConfigProviderOptionAny) -> Self {
2666            value.clone()
2667        }
2668    }
2669
2670    impl ::std::convert::From<::serde_json::Value> for ConfigProviderOptionAny {
2671        fn from(value: ::serde_json::Value) -> Self {
2672            Self(value)
2673        }
2674    }
2675
2676    ///`ConfigProviderOptionExample`
2677    ///
2678    /// <details><summary>JSON schema</summary>
2679    ///
2680    /// ```json
2681    ///{
2682    ///  "type": "object",
2683    ///  "required": [
2684    ///    "Help",
2685    ///    "Value"
2686    ///  ],
2687    ///  "properties": {
2688    ///    "Help": {
2689    ///      "type": "string"
2690    ///    },
2691    ///    "Provider": {
2692    ///      "type": "string"
2693    ///    },
2694    ///    "Value": {
2695    ///      "type": "string"
2696    ///    }
2697    ///  },
2698    ///  "additionalProperties": true
2699    ///}
2700    /// ```
2701    /// </details>
2702    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2703    pub struct ConfigProviderOptionExample {
2704        #[serde(rename = "Help")]
2705        pub help: ::std::string::String,
2706        #[serde(
2707            rename = "Provider",
2708            default,
2709            skip_serializing_if = "::std::option::Option::is_none"
2710        )]
2711        pub provider: ::std::option::Option<::std::string::String>,
2712        #[serde(rename = "Value")]
2713        pub value: ::std::string::String,
2714    }
2715
2716    impl ::std::convert::From<&ConfigProviderOptionExample> for ConfigProviderOptionExample {
2717        fn from(value: &ConfigProviderOptionExample) -> Self {
2718            value.clone()
2719        }
2720    }
2721
2722    ///`ConfigProviderOptionType`
2723    ///
2724    /// <details><summary>JSON schema</summary>
2725    ///
2726    /// ```json
2727    ///{
2728    ///  "type": "string",
2729    ///  "enum": [
2730    ///    "Bits",
2731    ///    "bool",
2732    ///    "CommaSepList",
2733    ///    "Duration",
2734    ///    "Encoding",
2735    ///    "int",
2736    ///    "mtime|atime|btime|ctime",
2737    ///    "SizeSuffix",
2738    ///    "SpaceSepList",
2739    ///    "string",
2740    ///    "stringArray",
2741    ///    "Time",
2742    ///    "Tristate"
2743    ///  ]
2744    ///}
2745    /// ```
2746    /// </details>
2747    #[derive(
2748        :: serde :: Deserialize,
2749        :: serde :: Serialize,
2750        Clone,
2751        Copy,
2752        Debug,
2753        Eq,
2754        Hash,
2755        Ord,
2756        PartialEq,
2757        PartialOrd,
2758    )]
2759    pub enum ConfigProviderOptionType {
2760        Bits,
2761        #[serde(rename = "bool")]
2762        Bool,
2763        CommaSepList,
2764        Duration,
2765        Encoding,
2766        #[serde(rename = "int")]
2767        Int,
2768        #[serde(rename = "mtime|atime|btime|ctime")]
2769        MtimeAtimeBtimeCtime,
2770        SizeSuffix,
2771        SpaceSepList,
2772        #[serde(rename = "string")]
2773        String,
2774        #[serde(rename = "stringArray")]
2775        StringArray,
2776        Time,
2777        Tristate,
2778    }
2779
2780    impl ::std::convert::From<&Self> for ConfigProviderOptionType {
2781        fn from(value: &ConfigProviderOptionType) -> Self {
2782            value.clone()
2783        }
2784    }
2785
2786    impl ::std::fmt::Display for ConfigProviderOptionType {
2787        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2788            match *self {
2789                Self::Bits => f.write_str("Bits"),
2790                Self::Bool => f.write_str("bool"),
2791                Self::CommaSepList => f.write_str("CommaSepList"),
2792                Self::Duration => f.write_str("Duration"),
2793                Self::Encoding => f.write_str("Encoding"),
2794                Self::Int => f.write_str("int"),
2795                Self::MtimeAtimeBtimeCtime => f.write_str("mtime|atime|btime|ctime"),
2796                Self::SizeSuffix => f.write_str("SizeSuffix"),
2797                Self::SpaceSepList => f.write_str("SpaceSepList"),
2798                Self::String => f.write_str("string"),
2799                Self::StringArray => f.write_str("stringArray"),
2800                Self::Time => f.write_str("Time"),
2801                Self::Tristate => f.write_str("Tristate"),
2802            }
2803        }
2804    }
2805
2806    impl ::std::str::FromStr for ConfigProviderOptionType {
2807        type Err = self::error::ConversionError;
2808        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2809            match value {
2810                "Bits" => Ok(Self::Bits),
2811                "bool" => Ok(Self::Bool),
2812                "CommaSepList" => Ok(Self::CommaSepList),
2813                "Duration" => Ok(Self::Duration),
2814                "Encoding" => Ok(Self::Encoding),
2815                "int" => Ok(Self::Int),
2816                "mtime|atime|btime|ctime" => Ok(Self::MtimeAtimeBtimeCtime),
2817                "SizeSuffix" => Ok(Self::SizeSuffix),
2818                "SpaceSepList" => Ok(Self::SpaceSepList),
2819                "string" => Ok(Self::String),
2820                "stringArray" => Ok(Self::StringArray),
2821                "Time" => Ok(Self::Time),
2822                "Tristate" => Ok(Self::Tristate),
2823                _ => Err("invalid value".into()),
2824            }
2825        }
2826    }
2827
2828    impl ::std::convert::TryFrom<&str> for ConfigProviderOptionType {
2829        type Error = self::error::ConversionError;
2830        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2831            value.parse()
2832        }
2833    }
2834
2835    impl ::std::convert::TryFrom<&::std::string::String> for ConfigProviderOptionType {
2836        type Error = self::error::ConversionError;
2837        fn try_from(
2838            value: &::std::string::String,
2839        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2840            value.parse()
2841        }
2842    }
2843
2844    impl ::std::convert::TryFrom<::std::string::String> for ConfigProviderOptionType {
2845        type Error = self::error::ConversionError;
2846        fn try_from(
2847            value: ::std::string::String,
2848        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2849            value.parse()
2850        }
2851    }
2852
2853    ///`ConfigProvidersPrefer`
2854    ///
2855    /// <details><summary>JSON schema</summary>
2856    ///
2857    /// ```json
2858    ///{
2859    ///  "type": "string",
2860    ///  "enum": [
2861    ///    "respond-async"
2862    ///  ]
2863    ///}
2864    /// ```
2865    /// </details>
2866    #[derive(
2867        :: serde :: Deserialize,
2868        :: serde :: Serialize,
2869        Clone,
2870        Copy,
2871        Debug,
2872        Eq,
2873        Hash,
2874        Ord,
2875        PartialEq,
2876        PartialOrd,
2877    )]
2878    pub enum ConfigProvidersPrefer {
2879        #[serde(rename = "respond-async")]
2880        RespondAsync,
2881    }
2882
2883    impl ::std::convert::From<&Self> for ConfigProvidersPrefer {
2884        fn from(value: &ConfigProvidersPrefer) -> Self {
2885            value.clone()
2886        }
2887    }
2888
2889    impl ::std::fmt::Display for ConfigProvidersPrefer {
2890        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2891            match *self {
2892                Self::RespondAsync => f.write_str("respond-async"),
2893            }
2894        }
2895    }
2896
2897    impl ::std::str::FromStr for ConfigProvidersPrefer {
2898        type Err = self::error::ConversionError;
2899        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2900            match value {
2901                "respond-async" => Ok(Self::RespondAsync),
2902                _ => Err("invalid value".into()),
2903            }
2904        }
2905    }
2906
2907    impl ::std::convert::TryFrom<&str> for ConfigProvidersPrefer {
2908        type Error = self::error::ConversionError;
2909        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
2910            value.parse()
2911        }
2912    }
2913
2914    impl ::std::convert::TryFrom<&::std::string::String> for ConfigProvidersPrefer {
2915        type Error = self::error::ConversionError;
2916        fn try_from(
2917            value: &::std::string::String,
2918        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2919            value.parse()
2920        }
2921    }
2922
2923    impl ::std::convert::TryFrom<::std::string::String> for ConfigProvidersPrefer {
2924        type Error = self::error::ConversionError;
2925        fn try_from(
2926            value: ::std::string::String,
2927        ) -> ::std::result::Result<Self, self::error::ConversionError> {
2928            value.parse()
2929        }
2930    }
2931
2932    ///`ConfigProvidersRequest`
2933    ///
2934    /// <details><summary>JSON schema</summary>
2935    ///
2936    /// ```json
2937    ///{
2938    ///  "type": "object",
2939    ///  "properties": {
2940    ///    "_async": {
2941    ///      "description": "Run the command asynchronously. Returns a job id
2942    /// immediately.",
2943    ///      "type": "boolean"
2944    ///    },
2945    ///    "_group": {
2946    ///      "description": "Assign the request to a custom stats group.",
2947    ///      "type": "string"
2948    ///    }
2949    ///  }
2950    ///}
2951    /// ```
2952    /// </details>
2953    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2954    pub struct ConfigProvidersRequest {
2955        ///Run the command asynchronously. Returns a job id immediately.
2956        #[serde(
2957            rename = "_async",
2958            default,
2959            skip_serializing_if = "::std::option::Option::is_none"
2960        )]
2961        pub async_: ::std::option::Option<bool>,
2962        ///Assign the request to a custom stats group.
2963        #[serde(
2964            rename = "_group",
2965            default,
2966            skip_serializing_if = "::std::option::Option::is_none"
2967        )]
2968        pub group: ::std::option::Option<::std::string::String>,
2969    }
2970
2971    impl ::std::convert::From<&ConfigProvidersRequest> for ConfigProvidersRequest {
2972        fn from(value: &ConfigProvidersRequest) -> Self {
2973            value.clone()
2974        }
2975    }
2976
2977    impl ::std::default::Default for ConfigProvidersRequest {
2978        fn default() -> Self {
2979            Self {
2980                async_: Default::default(),
2981                group: Default::default(),
2982            }
2983        }
2984    }
2985
2986    ///`ConfigProvidersResponse`
2987    ///
2988    /// <details><summary>JSON schema</summary>
2989    ///
2990    /// ```json
2991    ///{
2992    ///  "type": "object",
2993    ///  "required": [
2994    ///    "providers"
2995    ///  ],
2996    ///  "properties": {
2997    ///    "providers": {
2998    ///      "type": "array",
2999    ///      "items": {
3000    ///        "$ref": "#/components/schemas/ConfigProvider"
3001    ///      }
3002    ///    }
3003    ///  },
3004    ///  "additionalProperties": true
3005    ///}
3006    /// ```
3007    /// </details>
3008    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3009    pub struct ConfigProvidersResponse {
3010        pub providers: ::std::vec::Vec<ConfigProvider>,
3011    }
3012
3013    impl ::std::convert::From<&ConfigProvidersResponse> for ConfigProvidersResponse {
3014        fn from(value: &ConfigProvidersResponse) -> Self {
3015            value.clone()
3016        }
3017    }
3018
3019    ///`ConfigSetpathPrefer`
3020    ///
3021    /// <details><summary>JSON schema</summary>
3022    ///
3023    /// ```json
3024    ///{
3025    ///  "type": "string",
3026    ///  "enum": [
3027    ///    "respond-async"
3028    ///  ]
3029    ///}
3030    /// ```
3031    /// </details>
3032    #[derive(
3033        :: serde :: Deserialize,
3034        :: serde :: Serialize,
3035        Clone,
3036        Copy,
3037        Debug,
3038        Eq,
3039        Hash,
3040        Ord,
3041        PartialEq,
3042        PartialOrd,
3043    )]
3044    pub enum ConfigSetpathPrefer {
3045        #[serde(rename = "respond-async")]
3046        RespondAsync,
3047    }
3048
3049    impl ::std::convert::From<&Self> for ConfigSetpathPrefer {
3050        fn from(value: &ConfigSetpathPrefer) -> Self {
3051            value.clone()
3052        }
3053    }
3054
3055    impl ::std::fmt::Display for ConfigSetpathPrefer {
3056        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3057            match *self {
3058                Self::RespondAsync => f.write_str("respond-async"),
3059            }
3060        }
3061    }
3062
3063    impl ::std::str::FromStr for ConfigSetpathPrefer {
3064        type Err = self::error::ConversionError;
3065        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3066            match value {
3067                "respond-async" => Ok(Self::RespondAsync),
3068                _ => Err("invalid value".into()),
3069            }
3070        }
3071    }
3072
3073    impl ::std::convert::TryFrom<&str> for ConfigSetpathPrefer {
3074        type Error = self::error::ConversionError;
3075        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3076            value.parse()
3077        }
3078    }
3079
3080    impl ::std::convert::TryFrom<&::std::string::String> for ConfigSetpathPrefer {
3081        type Error = self::error::ConversionError;
3082        fn try_from(
3083            value: &::std::string::String,
3084        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3085            value.parse()
3086        }
3087    }
3088
3089    impl ::std::convert::TryFrom<::std::string::String> for ConfigSetpathPrefer {
3090        type Error = self::error::ConversionError;
3091        fn try_from(
3092            value: ::std::string::String,
3093        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3094            value.parse()
3095        }
3096    }
3097
3098    ///`ConfigSetpathRequest`
3099    ///
3100    /// <details><summary>JSON schema</summary>
3101    ///
3102    /// ```json
3103    ///{
3104    ///  "type": "object",
3105    ///  "properties": {
3106    ///    "_async": {
3107    ///      "description": "Run the command asynchronously. Returns a job id
3108    /// immediately.",
3109    ///      "type": "boolean"
3110    ///    },
3111    ///    "_group": {
3112    ///      "description": "Assign the request to a custom stats group.",
3113    ///      "type": "string"
3114    ///    },
3115    ///    "path": {
3116    ///      "description": "Absolute path to the `rclone.conf` file that rclone
3117    /// should use.",
3118    ///      "type": "string"
3119    ///    }
3120    ///  }
3121    ///}
3122    /// ```
3123    /// </details>
3124    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3125    pub struct ConfigSetpathRequest {
3126        ///Run the command asynchronously. Returns a job id immediately.
3127        #[serde(
3128            rename = "_async",
3129            default,
3130            skip_serializing_if = "::std::option::Option::is_none"
3131        )]
3132        pub async_: ::std::option::Option<bool>,
3133        ///Assign the request to a custom stats group.
3134        #[serde(
3135            rename = "_group",
3136            default,
3137            skip_serializing_if = "::std::option::Option::is_none"
3138        )]
3139        pub group: ::std::option::Option<::std::string::String>,
3140        ///Absolute path to the `rclone.conf` file that rclone should use.
3141        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3142        pub path: ::std::option::Option<::std::string::String>,
3143    }
3144
3145    impl ::std::convert::From<&ConfigSetpathRequest> for ConfigSetpathRequest {
3146        fn from(value: &ConfigSetpathRequest) -> Self {
3147            value.clone()
3148        }
3149    }
3150
3151    impl ::std::default::Default for ConfigSetpathRequest {
3152        fn default() -> Self {
3153            Self {
3154                async_: Default::default(),
3155                group: Default::default(),
3156                path: Default::default(),
3157            }
3158        }
3159    }
3160
3161    ///`ConfigUnlockPrefer`
3162    ///
3163    /// <details><summary>JSON schema</summary>
3164    ///
3165    /// ```json
3166    ///{
3167    ///  "type": "string",
3168    ///  "enum": [
3169    ///    "respond-async"
3170    ///  ]
3171    ///}
3172    /// ```
3173    /// </details>
3174    #[derive(
3175        :: serde :: Deserialize,
3176        :: serde :: Serialize,
3177        Clone,
3178        Copy,
3179        Debug,
3180        Eq,
3181        Hash,
3182        Ord,
3183        PartialEq,
3184        PartialOrd,
3185    )]
3186    pub enum ConfigUnlockPrefer {
3187        #[serde(rename = "respond-async")]
3188        RespondAsync,
3189    }
3190
3191    impl ::std::convert::From<&Self> for ConfigUnlockPrefer {
3192        fn from(value: &ConfigUnlockPrefer) -> Self {
3193            value.clone()
3194        }
3195    }
3196
3197    impl ::std::fmt::Display for ConfigUnlockPrefer {
3198        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3199            match *self {
3200                Self::RespondAsync => f.write_str("respond-async"),
3201            }
3202        }
3203    }
3204
3205    impl ::std::str::FromStr for ConfigUnlockPrefer {
3206        type Err = self::error::ConversionError;
3207        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3208            match value {
3209                "respond-async" => Ok(Self::RespondAsync),
3210                _ => Err("invalid value".into()),
3211            }
3212        }
3213    }
3214
3215    impl ::std::convert::TryFrom<&str> for ConfigUnlockPrefer {
3216        type Error = self::error::ConversionError;
3217        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3218            value.parse()
3219        }
3220    }
3221
3222    impl ::std::convert::TryFrom<&::std::string::String> for ConfigUnlockPrefer {
3223        type Error = self::error::ConversionError;
3224        fn try_from(
3225            value: &::std::string::String,
3226        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3227            value.parse()
3228        }
3229    }
3230
3231    impl ::std::convert::TryFrom<::std::string::String> for ConfigUnlockPrefer {
3232        type Error = self::error::ConversionError;
3233        fn try_from(
3234            value: ::std::string::String,
3235        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3236            value.parse()
3237        }
3238    }
3239
3240    ///`ConfigUnlockRequest`
3241    ///
3242    /// <details><summary>JSON schema</summary>
3243    ///
3244    /// ```json
3245    ///{
3246    ///  "type": "object",
3247    ///  "properties": {
3248    ///    "_async": {
3249    ///      "description": "Run the command asynchronously. Returns a job id
3250    /// immediately.",
3251    ///      "type": "boolean"
3252    ///    },
3253    ///    "_group": {
3254    ///      "description": "Assign the request to a custom stats group.",
3255    ///      "type": "string"
3256    ///    },
3257    ///    "configPassword": {
3258    ///      "description": "Password used to unlock an encrypted config file.",
3259    ///      "type": "string"
3260    ///    }
3261    ///  }
3262    ///}
3263    /// ```
3264    /// </details>
3265    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3266    pub struct ConfigUnlockRequest {
3267        ///Run the command asynchronously. Returns a job id immediately.
3268        #[serde(
3269            rename = "_async",
3270            default,
3271            skip_serializing_if = "::std::option::Option::is_none"
3272        )]
3273        pub async_: ::std::option::Option<bool>,
3274        ///Password used to unlock an encrypted config file.
3275        #[serde(
3276            rename = "configPassword",
3277            default,
3278            skip_serializing_if = "::std::option::Option::is_none"
3279        )]
3280        pub config_password: ::std::option::Option<::std::string::String>,
3281        ///Assign the request to a custom stats group.
3282        #[serde(
3283            rename = "_group",
3284            default,
3285            skip_serializing_if = "::std::option::Option::is_none"
3286        )]
3287        pub group: ::std::option::Option<::std::string::String>,
3288    }
3289
3290    impl ::std::convert::From<&ConfigUnlockRequest> for ConfigUnlockRequest {
3291        fn from(value: &ConfigUnlockRequest) -> Self {
3292            value.clone()
3293        }
3294    }
3295
3296    impl ::std::default::Default for ConfigUnlockRequest {
3297        fn default() -> Self {
3298            Self {
3299                async_: Default::default(),
3300                config_password: Default::default(),
3301                group: Default::default(),
3302            }
3303        }
3304    }
3305
3306    ///`ConfigUpdatePrefer`
3307    ///
3308    /// <details><summary>JSON schema</summary>
3309    ///
3310    /// ```json
3311    ///{
3312    ///  "type": "string",
3313    ///  "enum": [
3314    ///    "respond-async"
3315    ///  ]
3316    ///}
3317    /// ```
3318    /// </details>
3319    #[derive(
3320        :: serde :: Deserialize,
3321        :: serde :: Serialize,
3322        Clone,
3323        Copy,
3324        Debug,
3325        Eq,
3326        Hash,
3327        Ord,
3328        PartialEq,
3329        PartialOrd,
3330    )]
3331    pub enum ConfigUpdatePrefer {
3332        #[serde(rename = "respond-async")]
3333        RespondAsync,
3334    }
3335
3336    impl ::std::convert::From<&Self> for ConfigUpdatePrefer {
3337        fn from(value: &ConfigUpdatePrefer) -> Self {
3338            value.clone()
3339        }
3340    }
3341
3342    impl ::std::fmt::Display for ConfigUpdatePrefer {
3343        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3344            match *self {
3345                Self::RespondAsync => f.write_str("respond-async"),
3346            }
3347        }
3348    }
3349
3350    impl ::std::str::FromStr for ConfigUpdatePrefer {
3351        type Err = self::error::ConversionError;
3352        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3353            match value {
3354                "respond-async" => Ok(Self::RespondAsync),
3355                _ => Err("invalid value".into()),
3356            }
3357        }
3358    }
3359
3360    impl ::std::convert::TryFrom<&str> for ConfigUpdatePrefer {
3361        type Error = self::error::ConversionError;
3362        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3363            value.parse()
3364        }
3365    }
3366
3367    impl ::std::convert::TryFrom<&::std::string::String> for ConfigUpdatePrefer {
3368        type Error = self::error::ConversionError;
3369        fn try_from(
3370            value: &::std::string::String,
3371        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3372            value.parse()
3373        }
3374    }
3375
3376    impl ::std::convert::TryFrom<::std::string::String> for ConfigUpdatePrefer {
3377        type Error = self::error::ConversionError;
3378        fn try_from(
3379            value: ::std::string::String,
3380        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3381            value.parse()
3382        }
3383    }
3384
3385    ///`ConfigUpdateRequest`
3386    ///
3387    /// <details><summary>JSON schema</summary>
3388    ///
3389    /// ```json
3390    ///{
3391    ///  "type": "object",
3392    ///  "properties": {
3393    ///    "_async": {
3394    ///      "description": "Run the command asynchronously. Returns a job id
3395    /// immediately.",
3396    ///      "type": "boolean"
3397    ///    },
3398    ///    "_group": {
3399    ///      "description": "Assign the request to a custom stats group.",
3400    ///      "type": "string"
3401    ///    },
3402    ///    "name": {
3403    ///      "description": "Name of the remote configuration to update.",
3404    ///      "type": "string"
3405    ///    },
3406    ///    "opt": {
3407    ///      "description": "Optional JSON object controlling update behaviour
3408    /// (e.g. `obscure`, `continue`).",
3409    ///      "type": "string"
3410    ///    },
3411    ///    "parameters": {
3412    ///      "description": "JSON object of configuration key/value pairs to
3413    /// apply to the remote.",
3414    ///      "type": "string"
3415    ///    }
3416    ///  }
3417    ///}
3418    /// ```
3419    /// </details>
3420    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3421    pub struct ConfigUpdateRequest {
3422        ///Run the command asynchronously. Returns a job id immediately.
3423        #[serde(
3424            rename = "_async",
3425            default,
3426            skip_serializing_if = "::std::option::Option::is_none"
3427        )]
3428        pub async_: ::std::option::Option<bool>,
3429        ///Assign the request to a custom stats group.
3430        #[serde(
3431            rename = "_group",
3432            default,
3433            skip_serializing_if = "::std::option::Option::is_none"
3434        )]
3435        pub group: ::std::option::Option<::std::string::String>,
3436        ///Name of the remote configuration to update.
3437        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3438        pub name: ::std::option::Option<::std::string::String>,
3439        ///Optional JSON object controlling update behaviour (e.g. `obscure`,
3440        /// `continue`).
3441        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3442        pub opt: ::std::option::Option<::std::string::String>,
3443        ///JSON object of configuration key/value pairs to apply to the remote.
3444        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3445        pub parameters: ::std::option::Option<::std::string::String>,
3446    }
3447
3448    impl ::std::convert::From<&ConfigUpdateRequest> for ConfigUpdateRequest {
3449        fn from(value: &ConfigUpdateRequest) -> Self {
3450            value.clone()
3451        }
3452    }
3453
3454    impl ::std::default::Default for ConfigUpdateRequest {
3455        fn default() -> Self {
3456            Self {
3457                async_: Default::default(),
3458                group: Default::default(),
3459                name: Default::default(),
3460                opt: Default::default(),
3461                parameters: Default::default(),
3462            }
3463        }
3464    }
3465
3466    ///`CoreBwlimitPrefer`
3467    ///
3468    /// <details><summary>JSON schema</summary>
3469    ///
3470    /// ```json
3471    ///{
3472    ///  "type": "string",
3473    ///  "enum": [
3474    ///    "respond-async"
3475    ///  ]
3476    ///}
3477    /// ```
3478    /// </details>
3479    #[derive(
3480        :: serde :: Deserialize,
3481        :: serde :: Serialize,
3482        Clone,
3483        Copy,
3484        Debug,
3485        Eq,
3486        Hash,
3487        Ord,
3488        PartialEq,
3489        PartialOrd,
3490    )]
3491    pub enum CoreBwlimitPrefer {
3492        #[serde(rename = "respond-async")]
3493        RespondAsync,
3494    }
3495
3496    impl ::std::convert::From<&Self> for CoreBwlimitPrefer {
3497        fn from(value: &CoreBwlimitPrefer) -> Self {
3498            value.clone()
3499        }
3500    }
3501
3502    impl ::std::fmt::Display for CoreBwlimitPrefer {
3503        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3504            match *self {
3505                Self::RespondAsync => f.write_str("respond-async"),
3506            }
3507        }
3508    }
3509
3510    impl ::std::str::FromStr for CoreBwlimitPrefer {
3511        type Err = self::error::ConversionError;
3512        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3513            match value {
3514                "respond-async" => Ok(Self::RespondAsync),
3515                _ => Err("invalid value".into()),
3516            }
3517        }
3518    }
3519
3520    impl ::std::convert::TryFrom<&str> for CoreBwlimitPrefer {
3521        type Error = self::error::ConversionError;
3522        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3523            value.parse()
3524        }
3525    }
3526
3527    impl ::std::convert::TryFrom<&::std::string::String> for CoreBwlimitPrefer {
3528        type Error = self::error::ConversionError;
3529        fn try_from(
3530            value: &::std::string::String,
3531        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3532            value.parse()
3533        }
3534    }
3535
3536    impl ::std::convert::TryFrom<::std::string::String> for CoreBwlimitPrefer {
3537        type Error = self::error::ConversionError;
3538        fn try_from(
3539            value: ::std::string::String,
3540        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3541            value.parse()
3542        }
3543    }
3544
3545    ///`CoreBwlimitRequest`
3546    ///
3547    /// <details><summary>JSON schema</summary>
3548    ///
3549    /// ```json
3550    ///{
3551    ///  "type": "object",
3552    ///  "properties": {
3553    ///    "_async": {
3554    ///      "description": "Run the command asynchronously. Returns a job id
3555    /// immediately.",
3556    ///      "type": "boolean"
3557    ///    },
3558    ///    "_group": {
3559    ///      "description": "Assign the request to a custom stats group.",
3560    ///      "type": "string"
3561    ///    },
3562    ///    "rate": {
3563    ///      "description": "Bandwidth limit to apply, for example `off`, `5M`,
3564    /// or a schedule string.",
3565    ///      "type": "string"
3566    ///    }
3567    ///  }
3568    ///}
3569    /// ```
3570    /// </details>
3571    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3572    pub struct CoreBwlimitRequest {
3573        ///Run the command asynchronously. Returns a job id immediately.
3574        #[serde(
3575            rename = "_async",
3576            default,
3577            skip_serializing_if = "::std::option::Option::is_none"
3578        )]
3579        pub async_: ::std::option::Option<bool>,
3580        ///Assign the request to a custom stats group.
3581        #[serde(
3582            rename = "_group",
3583            default,
3584            skip_serializing_if = "::std::option::Option::is_none"
3585        )]
3586        pub group: ::std::option::Option<::std::string::String>,
3587        ///Bandwidth limit to apply, for example `off`, `5M`, or a schedule
3588        /// string.
3589        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3590        pub rate: ::std::option::Option<::std::string::String>,
3591    }
3592
3593    impl ::std::convert::From<&CoreBwlimitRequest> for CoreBwlimitRequest {
3594        fn from(value: &CoreBwlimitRequest) -> Self {
3595            value.clone()
3596        }
3597    }
3598
3599    impl ::std::default::Default for CoreBwlimitRequest {
3600        fn default() -> Self {
3601            Self {
3602                async_: Default::default(),
3603                group: Default::default(),
3604                rate: Default::default(),
3605            }
3606        }
3607    }
3608
3609    ///`CoreBwlimitResponse`
3610    ///
3611    /// <details><summary>JSON schema</summary>
3612    ///
3613    /// ```json
3614    ///{
3615    ///  "type": "object",
3616    ///  "required": [
3617    ///    "bytesPerSecond",
3618    ///    "bytesPerSecondRx",
3619    ///    "bytesPerSecondTx",
3620    ///    "rate"
3621    ///  ],
3622    ///  "properties": {
3623    ///    "bytesPerSecond": {
3624    ///      "type": "integer"
3625    ///    },
3626    ///    "bytesPerSecondRx": {
3627    ///      "type": "integer"
3628    ///    },
3629    ///    "bytesPerSecondTx": {
3630    ///      "type": "integer"
3631    ///    },
3632    ///    "rate": {
3633    ///      "type": "string"
3634    ///    }
3635    ///  }
3636    ///}
3637    /// ```
3638    /// </details>
3639    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3640    pub struct CoreBwlimitResponse {
3641        #[serde(rename = "bytesPerSecond")]
3642        pub bytes_per_second: i64,
3643        #[serde(rename = "bytesPerSecondRx")]
3644        pub bytes_per_second_rx: i64,
3645        #[serde(rename = "bytesPerSecondTx")]
3646        pub bytes_per_second_tx: i64,
3647        pub rate: ::std::string::String,
3648    }
3649
3650    impl ::std::convert::From<&CoreBwlimitResponse> for CoreBwlimitResponse {
3651        fn from(value: &CoreBwlimitResponse) -> Self {
3652            value.clone()
3653        }
3654    }
3655
3656    ///`CoreCommandPrefer`
3657    ///
3658    /// <details><summary>JSON schema</summary>
3659    ///
3660    /// ```json
3661    ///{
3662    ///  "type": "string",
3663    ///  "enum": [
3664    ///    "respond-async"
3665    ///  ]
3666    ///}
3667    /// ```
3668    /// </details>
3669    #[derive(
3670        :: serde :: Deserialize,
3671        :: serde :: Serialize,
3672        Clone,
3673        Copy,
3674        Debug,
3675        Eq,
3676        Hash,
3677        Ord,
3678        PartialEq,
3679        PartialOrd,
3680    )]
3681    pub enum CoreCommandPrefer {
3682        #[serde(rename = "respond-async")]
3683        RespondAsync,
3684    }
3685
3686    impl ::std::convert::From<&Self> for CoreCommandPrefer {
3687        fn from(value: &CoreCommandPrefer) -> Self {
3688            value.clone()
3689        }
3690    }
3691
3692    impl ::std::fmt::Display for CoreCommandPrefer {
3693        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3694            match *self {
3695                Self::RespondAsync => f.write_str("respond-async"),
3696            }
3697        }
3698    }
3699
3700    impl ::std::str::FromStr for CoreCommandPrefer {
3701        type Err = self::error::ConversionError;
3702        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3703            match value {
3704                "respond-async" => Ok(Self::RespondAsync),
3705                _ => Err("invalid value".into()),
3706            }
3707        }
3708    }
3709
3710    impl ::std::convert::TryFrom<&str> for CoreCommandPrefer {
3711        type Error = self::error::ConversionError;
3712        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3713            value.parse()
3714        }
3715    }
3716
3717    impl ::std::convert::TryFrom<&::std::string::String> for CoreCommandPrefer {
3718        type Error = self::error::ConversionError;
3719        fn try_from(
3720            value: &::std::string::String,
3721        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3722            value.parse()
3723        }
3724    }
3725
3726    impl ::std::convert::TryFrom<::std::string::String> for CoreCommandPrefer {
3727        type Error = self::error::ConversionError;
3728        fn try_from(
3729            value: ::std::string::String,
3730        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3731            value.parse()
3732        }
3733    }
3734
3735    ///`CoreCommandRequest`
3736    ///
3737    /// <details><summary>JSON schema</summary>
3738    ///
3739    /// ```json
3740    ///{
3741    ///  "type": "object",
3742    ///  "properties": {
3743    ///    "_async": {
3744    ///      "description": "Run the command asynchronously. Returns a job id
3745    /// immediately.",
3746    ///      "type": "boolean"
3747    ///    },
3748    ///    "_group": {
3749    ///      "description": "Assign the request to a custom stats group.",
3750    ///      "type": "string"
3751    ///    },
3752    ///    "arg": {
3753    ///      "description": "Optional positional arguments for the command.
3754    /// Repeat to supply multiple values.",
3755    ///      "type": "array",
3756    ///      "items": {
3757    ///        "type": "string"
3758    ///      }
3759    ///    },
3760    ///    "command": {
3761    ///      "description": "Name of the rclone command to execute, for example
3762    /// `ls` or `lsf`.",
3763    ///      "type": "string"
3764    ///    },
3765    ///    "opt": {
3766    ///      "description": "Optional command options encoded as a JSON
3767    /// string.",
3768    ///      "type": "string"
3769    ///    },
3770    ///    "returnType": {
3771    ///      "description": "Controls how output is returned; accepts
3772    /// `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
3773    /// `STREAM_ONLY_STDERR`.",
3774    ///      "type": "string"
3775    ///    }
3776    ///  }
3777    ///}
3778    /// ```
3779    /// </details>
3780    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3781    pub struct CoreCommandRequest {
3782        ///Optional positional arguments for the command. Repeat to supply
3783        /// multiple values.
3784        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
3785        pub arg: ::std::vec::Vec<::std::string::String>,
3786        ///Run the command asynchronously. Returns a job id immediately.
3787        #[serde(
3788            rename = "_async",
3789            default,
3790            skip_serializing_if = "::std::option::Option::is_none"
3791        )]
3792        pub async_: ::std::option::Option<bool>,
3793        ///Name of the rclone command to execute, for example `ls` or `lsf`.
3794        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3795        pub command: ::std::option::Option<::std::string::String>,
3796        ///Assign the request to a custom stats group.
3797        #[serde(
3798            rename = "_group",
3799            default,
3800            skip_serializing_if = "::std::option::Option::is_none"
3801        )]
3802        pub group: ::std::option::Option<::std::string::String>,
3803        ///Optional command options encoded as a JSON string.
3804        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3805        pub opt: ::std::option::Option<::std::string::String>,
3806        ///Controls how output is returned; accepts `COMBINED_OUTPUT`,
3807        /// `STREAM`, `STREAM_ONLY_STDOUT`, or `STREAM_ONLY_STDERR`.
3808        #[serde(
3809            rename = "returnType",
3810            default,
3811            skip_serializing_if = "::std::option::Option::is_none"
3812        )]
3813        pub return_type: ::std::option::Option<::std::string::String>,
3814    }
3815
3816    impl ::std::convert::From<&CoreCommandRequest> for CoreCommandRequest {
3817        fn from(value: &CoreCommandRequest) -> Self {
3818            value.clone()
3819        }
3820    }
3821
3822    impl ::std::default::Default for CoreCommandRequest {
3823        fn default() -> Self {
3824            Self {
3825                arg: Default::default(),
3826                async_: Default::default(),
3827                command: Default::default(),
3828                group: Default::default(),
3829                opt: Default::default(),
3830                return_type: Default::default(),
3831            }
3832        }
3833    }
3834
3835    ///`CoreCommandResponse`
3836    ///
3837    /// <details><summary>JSON schema</summary>
3838    ///
3839    /// ```json
3840    ///{
3841    ///  "type": "object",
3842    ///  "required": [
3843    ///    "error"
3844    ///  ],
3845    ///  "properties": {
3846    ///    "error": {
3847    ///      "type": "boolean"
3848    ///    },
3849    ///    "result": {
3850    ///      "type": [
3851    ///        "string",
3852    ///        "null"
3853    ///      ]
3854    ///    },
3855    ///    "returnType": {
3856    ///      "type": [
3857    ///        "string",
3858    ///        "null"
3859    ///      ]
3860    ///    }
3861    ///  }
3862    ///}
3863    /// ```
3864    /// </details>
3865    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3866    pub struct CoreCommandResponse {
3867        pub error: bool,
3868        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3869        pub result: ::std::option::Option<::std::string::String>,
3870        #[serde(
3871            rename = "returnType",
3872            default,
3873            skip_serializing_if = "::std::option::Option::is_none"
3874        )]
3875        pub return_type: ::std::option::Option<::std::string::String>,
3876    }
3877
3878    impl ::std::convert::From<&CoreCommandResponse> for CoreCommandResponse {
3879        fn from(value: &CoreCommandResponse) -> Self {
3880            value.clone()
3881        }
3882    }
3883
3884    ///`CoreDisksPrefer`
3885    ///
3886    /// <details><summary>JSON schema</summary>
3887    ///
3888    /// ```json
3889    ///{
3890    ///  "type": "string",
3891    ///  "enum": [
3892    ///    "respond-async"
3893    ///  ]
3894    ///}
3895    /// ```
3896    /// </details>
3897    #[derive(
3898        :: serde :: Deserialize,
3899        :: serde :: Serialize,
3900        Clone,
3901        Copy,
3902        Debug,
3903        Eq,
3904        Hash,
3905        Ord,
3906        PartialEq,
3907        PartialOrd,
3908    )]
3909    pub enum CoreDisksPrefer {
3910        #[serde(rename = "respond-async")]
3911        RespondAsync,
3912    }
3913
3914    impl ::std::convert::From<&Self> for CoreDisksPrefer {
3915        fn from(value: &CoreDisksPrefer) -> Self {
3916            value.clone()
3917        }
3918    }
3919
3920    impl ::std::fmt::Display for CoreDisksPrefer {
3921        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3922            match *self {
3923                Self::RespondAsync => f.write_str("respond-async"),
3924            }
3925        }
3926    }
3927
3928    impl ::std::str::FromStr for CoreDisksPrefer {
3929        type Err = self::error::ConversionError;
3930        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3931            match value {
3932                "respond-async" => Ok(Self::RespondAsync),
3933                _ => Err("invalid value".into()),
3934            }
3935        }
3936    }
3937
3938    impl ::std::convert::TryFrom<&str> for CoreDisksPrefer {
3939        type Error = self::error::ConversionError;
3940        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3941            value.parse()
3942        }
3943    }
3944
3945    impl ::std::convert::TryFrom<&::std::string::String> for CoreDisksPrefer {
3946        type Error = self::error::ConversionError;
3947        fn try_from(
3948            value: &::std::string::String,
3949        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3950            value.parse()
3951        }
3952    }
3953
3954    impl ::std::convert::TryFrom<::std::string::String> for CoreDisksPrefer {
3955        type Error = self::error::ConversionError;
3956        fn try_from(
3957            value: ::std::string::String,
3958        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3959            value.parse()
3960        }
3961    }
3962
3963    ///`CoreDisksRequest`
3964    ///
3965    /// <details><summary>JSON schema</summary>
3966    ///
3967    /// ```json
3968    ///{
3969    ///  "type": "object",
3970    ///  "properties": {
3971    ///    "_async": {
3972    ///      "description": "Run the command asynchronously. Returns a job id
3973    /// immediately.",
3974    ///      "type": "boolean"
3975    ///    },
3976    ///    "_group": {
3977    ///      "description": "Assign the request to a custom stats group.",
3978    ///      "type": "string"
3979    ///    }
3980    ///  }
3981    ///}
3982    /// ```
3983    /// </details>
3984    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3985    pub struct CoreDisksRequest {
3986        ///Run the command asynchronously. Returns a job id immediately.
3987        #[serde(
3988            rename = "_async",
3989            default,
3990            skip_serializing_if = "::std::option::Option::is_none"
3991        )]
3992        pub async_: ::std::option::Option<bool>,
3993        ///Assign the request to a custom stats group.
3994        #[serde(
3995            rename = "_group",
3996            default,
3997            skip_serializing_if = "::std::option::Option::is_none"
3998        )]
3999        pub group: ::std::option::Option<::std::string::String>,
4000    }
4001
4002    impl ::std::convert::From<&CoreDisksRequest> for CoreDisksRequest {
4003        fn from(value: &CoreDisksRequest) -> Self {
4004            value.clone()
4005        }
4006    }
4007
4008    impl ::std::default::Default for CoreDisksRequest {
4009        fn default() -> Self {
4010            Self {
4011                async_: Default::default(),
4012                group: Default::default(),
4013            }
4014        }
4015    }
4016
4017    ///`CoreDisksResponse`
4018    ///
4019    /// <details><summary>JSON schema</summary>
4020    ///
4021    /// ```json
4022    ///{
4023    ///  "type": "object",
4024    ///  "required": [
4025    ///    "disks"
4026    ///  ],
4027    ///  "properties": {
4028    ///    "disks": {
4029    ///      "description": "Accessible local paths such as disk mount points,
4030    /// user home folders, and removable volumes.",
4031    ///      "type": "array",
4032    ///      "items": {
4033    ///        "type": "string"
4034    ///      }
4035    ///    }
4036    ///  }
4037    ///}
4038    /// ```
4039    /// </details>
4040    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4041    pub struct CoreDisksResponse {
4042        ///Accessible local paths such as disk mount points, user home folders,
4043        /// and removable volumes.
4044        pub disks: ::std::vec::Vec<::std::string::String>,
4045    }
4046
4047    impl ::std::convert::From<&CoreDisksResponse> for CoreDisksResponse {
4048        fn from(value: &CoreDisksResponse) -> Self {
4049            value.clone()
4050        }
4051    }
4052
4053    ///`CoreDuPrefer`
4054    ///
4055    /// <details><summary>JSON schema</summary>
4056    ///
4057    /// ```json
4058    ///{
4059    ///  "type": "string",
4060    ///  "enum": [
4061    ///    "respond-async"
4062    ///  ]
4063    ///}
4064    /// ```
4065    /// </details>
4066    #[derive(
4067        :: serde :: Deserialize,
4068        :: serde :: Serialize,
4069        Clone,
4070        Copy,
4071        Debug,
4072        Eq,
4073        Hash,
4074        Ord,
4075        PartialEq,
4076        PartialOrd,
4077    )]
4078    pub enum CoreDuPrefer {
4079        #[serde(rename = "respond-async")]
4080        RespondAsync,
4081    }
4082
4083    impl ::std::convert::From<&Self> for CoreDuPrefer {
4084        fn from(value: &CoreDuPrefer) -> Self {
4085            value.clone()
4086        }
4087    }
4088
4089    impl ::std::fmt::Display for CoreDuPrefer {
4090        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4091            match *self {
4092                Self::RespondAsync => f.write_str("respond-async"),
4093            }
4094        }
4095    }
4096
4097    impl ::std::str::FromStr for CoreDuPrefer {
4098        type Err = self::error::ConversionError;
4099        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4100            match value {
4101                "respond-async" => Ok(Self::RespondAsync),
4102                _ => Err("invalid value".into()),
4103            }
4104        }
4105    }
4106
4107    impl ::std::convert::TryFrom<&str> for CoreDuPrefer {
4108        type Error = self::error::ConversionError;
4109        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4110            value.parse()
4111        }
4112    }
4113
4114    impl ::std::convert::TryFrom<&::std::string::String> for CoreDuPrefer {
4115        type Error = self::error::ConversionError;
4116        fn try_from(
4117            value: &::std::string::String,
4118        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4119            value.parse()
4120        }
4121    }
4122
4123    impl ::std::convert::TryFrom<::std::string::String> for CoreDuPrefer {
4124        type Error = self::error::ConversionError;
4125        fn try_from(
4126            value: ::std::string::String,
4127        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4128            value.parse()
4129        }
4130    }
4131
4132    ///`CoreDuRequest`
4133    ///
4134    /// <details><summary>JSON schema</summary>
4135    ///
4136    /// ```json
4137    ///{
4138    ///  "type": "object",
4139    ///  "properties": {
4140    ///    "_async": {
4141    ///      "description": "Run the command asynchronously. Returns a job id
4142    /// immediately.",
4143    ///      "type": "boolean"
4144    ///    },
4145    ///    "_group": {
4146    ///      "description": "Assign the request to a custom stats group.",
4147    ///      "type": "string"
4148    ///    },
4149    ///    "dir": {
4150    ///      "description": "Local directory path to report disk usage for.
4151    /// Defaults to the rclone cache directory when omitted.",
4152    ///      "type": "string"
4153    ///    }
4154    ///  }
4155    ///}
4156    /// ```
4157    /// </details>
4158    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4159    pub struct CoreDuRequest {
4160        ///Run the command asynchronously. Returns a job id immediately.
4161        #[serde(
4162            rename = "_async",
4163            default,
4164            skip_serializing_if = "::std::option::Option::is_none"
4165        )]
4166        pub async_: ::std::option::Option<bool>,
4167        ///Local directory path to report disk usage for. Defaults to the
4168        /// rclone cache directory when omitted.
4169        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4170        pub dir: ::std::option::Option<::std::string::String>,
4171        ///Assign the request to a custom stats group.
4172        #[serde(
4173            rename = "_group",
4174            default,
4175            skip_serializing_if = "::std::option::Option::is_none"
4176        )]
4177        pub group: ::std::option::Option<::std::string::String>,
4178    }
4179
4180    impl ::std::convert::From<&CoreDuRequest> for CoreDuRequest {
4181        fn from(value: &CoreDuRequest) -> Self {
4182            value.clone()
4183        }
4184    }
4185
4186    impl ::std::default::Default for CoreDuRequest {
4187        fn default() -> Self {
4188            Self {
4189                async_: Default::default(),
4190                dir: Default::default(),
4191                group: Default::default(),
4192            }
4193        }
4194    }
4195
4196    ///`CoreDuResponse`
4197    ///
4198    /// <details><summary>JSON schema</summary>
4199    ///
4200    /// ```json
4201    ///{
4202    ///  "type": "object",
4203    ///  "required": [
4204    ///    "dir",
4205    ///    "info"
4206    ///  ],
4207    ///  "properties": {
4208    ///    "dir": {
4209    ///      "type": "string"
4210    ///    },
4211    ///    "info": {
4212    ///      "type": "object",
4213    ///      "required": [
4214    ///        "Available",
4215    ///        "Free",
4216    ///        "Total"
4217    ///      ],
4218    ///      "properties": {
4219    ///        "Available": {
4220    ///          "type": "integer"
4221    ///        },
4222    ///        "Free": {
4223    ///          "type": "integer"
4224    ///        },
4225    ///        "Total": {
4226    ///          "type": "integer"
4227    ///        }
4228    ///      }
4229    ///    }
4230    ///  }
4231    ///}
4232    /// ```
4233    /// </details>
4234    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4235    pub struct CoreDuResponse {
4236        pub dir: ::std::string::String,
4237        pub info: CoreDuResponseInfo,
4238    }
4239
4240    impl ::std::convert::From<&CoreDuResponse> for CoreDuResponse {
4241        fn from(value: &CoreDuResponse) -> Self {
4242            value.clone()
4243        }
4244    }
4245
4246    ///`CoreDuResponseInfo`
4247    ///
4248    /// <details><summary>JSON schema</summary>
4249    ///
4250    /// ```json
4251    ///{
4252    ///  "type": "object",
4253    ///  "required": [
4254    ///    "Available",
4255    ///    "Free",
4256    ///    "Total"
4257    ///  ],
4258    ///  "properties": {
4259    ///    "Available": {
4260    ///      "type": "integer"
4261    ///    },
4262    ///    "Free": {
4263    ///      "type": "integer"
4264    ///    },
4265    ///    "Total": {
4266    ///      "type": "integer"
4267    ///    }
4268    ///  }
4269    ///}
4270    /// ```
4271    /// </details>
4272    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4273    pub struct CoreDuResponseInfo {
4274        #[serde(rename = "Available")]
4275        pub available: i64,
4276        #[serde(rename = "Free")]
4277        pub free: i64,
4278        #[serde(rename = "Total")]
4279        pub total: i64,
4280    }
4281
4282    impl ::std::convert::From<&CoreDuResponseInfo> for CoreDuResponseInfo {
4283        fn from(value: &CoreDuResponseInfo) -> Self {
4284            value.clone()
4285        }
4286    }
4287
4288    ///`CoreGcPrefer`
4289    ///
4290    /// <details><summary>JSON schema</summary>
4291    ///
4292    /// ```json
4293    ///{
4294    ///  "type": "string",
4295    ///  "enum": [
4296    ///    "respond-async"
4297    ///  ]
4298    ///}
4299    /// ```
4300    /// </details>
4301    #[derive(
4302        :: serde :: Deserialize,
4303        :: serde :: Serialize,
4304        Clone,
4305        Copy,
4306        Debug,
4307        Eq,
4308        Hash,
4309        Ord,
4310        PartialEq,
4311        PartialOrd,
4312    )]
4313    pub enum CoreGcPrefer {
4314        #[serde(rename = "respond-async")]
4315        RespondAsync,
4316    }
4317
4318    impl ::std::convert::From<&Self> for CoreGcPrefer {
4319        fn from(value: &CoreGcPrefer) -> Self {
4320            value.clone()
4321        }
4322    }
4323
4324    impl ::std::fmt::Display for CoreGcPrefer {
4325        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4326            match *self {
4327                Self::RespondAsync => f.write_str("respond-async"),
4328            }
4329        }
4330    }
4331
4332    impl ::std::str::FromStr for CoreGcPrefer {
4333        type Err = self::error::ConversionError;
4334        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4335            match value {
4336                "respond-async" => Ok(Self::RespondAsync),
4337                _ => Err("invalid value".into()),
4338            }
4339        }
4340    }
4341
4342    impl ::std::convert::TryFrom<&str> for CoreGcPrefer {
4343        type Error = self::error::ConversionError;
4344        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4345            value.parse()
4346        }
4347    }
4348
4349    impl ::std::convert::TryFrom<&::std::string::String> for CoreGcPrefer {
4350        type Error = self::error::ConversionError;
4351        fn try_from(
4352            value: &::std::string::String,
4353        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4354            value.parse()
4355        }
4356    }
4357
4358    impl ::std::convert::TryFrom<::std::string::String> for CoreGcPrefer {
4359        type Error = self::error::ConversionError;
4360        fn try_from(
4361            value: ::std::string::String,
4362        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4363            value.parse()
4364        }
4365    }
4366
4367    ///`CoreGcRequest`
4368    ///
4369    /// <details><summary>JSON schema</summary>
4370    ///
4371    /// ```json
4372    ///{
4373    ///  "type": "object",
4374    ///  "properties": {
4375    ///    "_async": {
4376    ///      "description": "Run the command asynchronously. Returns a job id
4377    /// immediately.",
4378    ///      "type": "boolean"
4379    ///    },
4380    ///    "_group": {
4381    ///      "description": "Assign the request to a custom stats group.",
4382    ///      "type": "string"
4383    ///    }
4384    ///  }
4385    ///}
4386    /// ```
4387    /// </details>
4388    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4389    pub struct CoreGcRequest {
4390        ///Run the command asynchronously. Returns a job id immediately.
4391        #[serde(
4392            rename = "_async",
4393            default,
4394            skip_serializing_if = "::std::option::Option::is_none"
4395        )]
4396        pub async_: ::std::option::Option<bool>,
4397        ///Assign the request to a custom stats group.
4398        #[serde(
4399            rename = "_group",
4400            default,
4401            skip_serializing_if = "::std::option::Option::is_none"
4402        )]
4403        pub group: ::std::option::Option<::std::string::String>,
4404    }
4405
4406    impl ::std::convert::From<&CoreGcRequest> for CoreGcRequest {
4407        fn from(value: &CoreGcRequest) -> Self {
4408            value.clone()
4409        }
4410    }
4411
4412    impl ::std::default::Default for CoreGcRequest {
4413        fn default() -> Self {
4414            Self {
4415                async_: Default::default(),
4416                group: Default::default(),
4417            }
4418        }
4419    }
4420
4421    ///`CoreGroupListPrefer`
4422    ///
4423    /// <details><summary>JSON schema</summary>
4424    ///
4425    /// ```json
4426    ///{
4427    ///  "type": "string",
4428    ///  "enum": [
4429    ///    "respond-async"
4430    ///  ]
4431    ///}
4432    /// ```
4433    /// </details>
4434    #[derive(
4435        :: serde :: Deserialize,
4436        :: serde :: Serialize,
4437        Clone,
4438        Copy,
4439        Debug,
4440        Eq,
4441        Hash,
4442        Ord,
4443        PartialEq,
4444        PartialOrd,
4445    )]
4446    pub enum CoreGroupListPrefer {
4447        #[serde(rename = "respond-async")]
4448        RespondAsync,
4449    }
4450
4451    impl ::std::convert::From<&Self> for CoreGroupListPrefer {
4452        fn from(value: &CoreGroupListPrefer) -> Self {
4453            value.clone()
4454        }
4455    }
4456
4457    impl ::std::fmt::Display for CoreGroupListPrefer {
4458        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4459            match *self {
4460                Self::RespondAsync => f.write_str("respond-async"),
4461            }
4462        }
4463    }
4464
4465    impl ::std::str::FromStr for CoreGroupListPrefer {
4466        type Err = self::error::ConversionError;
4467        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4468            match value {
4469                "respond-async" => Ok(Self::RespondAsync),
4470                _ => Err("invalid value".into()),
4471            }
4472        }
4473    }
4474
4475    impl ::std::convert::TryFrom<&str> for CoreGroupListPrefer {
4476        type Error = self::error::ConversionError;
4477        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4478            value.parse()
4479        }
4480    }
4481
4482    impl ::std::convert::TryFrom<&::std::string::String> for CoreGroupListPrefer {
4483        type Error = self::error::ConversionError;
4484        fn try_from(
4485            value: &::std::string::String,
4486        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4487            value.parse()
4488        }
4489    }
4490
4491    impl ::std::convert::TryFrom<::std::string::String> for CoreGroupListPrefer {
4492        type Error = self::error::ConversionError;
4493        fn try_from(
4494            value: ::std::string::String,
4495        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4496            value.parse()
4497        }
4498    }
4499
4500    ///`CoreGroupListRequest`
4501    ///
4502    /// <details><summary>JSON schema</summary>
4503    ///
4504    /// ```json
4505    ///{
4506    ///  "type": "object",
4507    ///  "properties": {
4508    ///    "_async": {
4509    ///      "description": "Run the command asynchronously. Returns a job id
4510    /// immediately.",
4511    ///      "type": "boolean"
4512    ///    },
4513    ///    "_group": {
4514    ///      "description": "Assign the request to a custom stats group.",
4515    ///      "type": "string"
4516    ///    }
4517    ///  }
4518    ///}
4519    /// ```
4520    /// </details>
4521    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4522    pub struct CoreGroupListRequest {
4523        ///Run the command asynchronously. Returns a job id immediately.
4524        #[serde(
4525            rename = "_async",
4526            default,
4527            skip_serializing_if = "::std::option::Option::is_none"
4528        )]
4529        pub async_: ::std::option::Option<bool>,
4530        ///Assign the request to a custom stats group.
4531        #[serde(
4532            rename = "_group",
4533            default,
4534            skip_serializing_if = "::std::option::Option::is_none"
4535        )]
4536        pub group: ::std::option::Option<::std::string::String>,
4537    }
4538
4539    impl ::std::convert::From<&CoreGroupListRequest> for CoreGroupListRequest {
4540        fn from(value: &CoreGroupListRequest) -> Self {
4541            value.clone()
4542        }
4543    }
4544
4545    impl ::std::default::Default for CoreGroupListRequest {
4546        fn default() -> Self {
4547            Self {
4548                async_: Default::default(),
4549                group: Default::default(),
4550            }
4551        }
4552    }
4553
4554    ///`CoreGroupListResponse`
4555    ///
4556    /// <details><summary>JSON schema</summary>
4557    ///
4558    /// ```json
4559    ///{
4560    ///  "type": "object",
4561    ///  "required": [
4562    ///    "groups"
4563    ///  ],
4564    ///  "properties": {
4565    ///    "groups": {
4566    ///      "type": "array",
4567    ///      "items": {
4568    ///        "type": "string"
4569    ///      }
4570    ///    }
4571    ///  }
4572    ///}
4573    /// ```
4574    /// </details>
4575    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4576    pub struct CoreGroupListResponse {
4577        pub groups: ::std::vec::Vec<::std::string::String>,
4578    }
4579
4580    impl ::std::convert::From<&CoreGroupListResponse> for CoreGroupListResponse {
4581        fn from(value: &CoreGroupListResponse) -> Self {
4582            value.clone()
4583        }
4584    }
4585
4586    ///`CoreMemstatsPrefer`
4587    ///
4588    /// <details><summary>JSON schema</summary>
4589    ///
4590    /// ```json
4591    ///{
4592    ///  "type": "string",
4593    ///  "enum": [
4594    ///    "respond-async"
4595    ///  ]
4596    ///}
4597    /// ```
4598    /// </details>
4599    #[derive(
4600        :: serde :: Deserialize,
4601        :: serde :: Serialize,
4602        Clone,
4603        Copy,
4604        Debug,
4605        Eq,
4606        Hash,
4607        Ord,
4608        PartialEq,
4609        PartialOrd,
4610    )]
4611    pub enum CoreMemstatsPrefer {
4612        #[serde(rename = "respond-async")]
4613        RespondAsync,
4614    }
4615
4616    impl ::std::convert::From<&Self> for CoreMemstatsPrefer {
4617        fn from(value: &CoreMemstatsPrefer) -> Self {
4618            value.clone()
4619        }
4620    }
4621
4622    impl ::std::fmt::Display for CoreMemstatsPrefer {
4623        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4624            match *self {
4625                Self::RespondAsync => f.write_str("respond-async"),
4626            }
4627        }
4628    }
4629
4630    impl ::std::str::FromStr for CoreMemstatsPrefer {
4631        type Err = self::error::ConversionError;
4632        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4633            match value {
4634                "respond-async" => Ok(Self::RespondAsync),
4635                _ => Err("invalid value".into()),
4636            }
4637        }
4638    }
4639
4640    impl ::std::convert::TryFrom<&str> for CoreMemstatsPrefer {
4641        type Error = self::error::ConversionError;
4642        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4643            value.parse()
4644        }
4645    }
4646
4647    impl ::std::convert::TryFrom<&::std::string::String> for CoreMemstatsPrefer {
4648        type Error = self::error::ConversionError;
4649        fn try_from(
4650            value: &::std::string::String,
4651        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4652            value.parse()
4653        }
4654    }
4655
4656    impl ::std::convert::TryFrom<::std::string::String> for CoreMemstatsPrefer {
4657        type Error = self::error::ConversionError;
4658        fn try_from(
4659            value: ::std::string::String,
4660        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4661            value.parse()
4662        }
4663    }
4664
4665    ///`CoreMemstatsRequest`
4666    ///
4667    /// <details><summary>JSON schema</summary>
4668    ///
4669    /// ```json
4670    ///{
4671    ///  "type": "object",
4672    ///  "properties": {
4673    ///    "_async": {
4674    ///      "description": "Run the command asynchronously. Returns a job id
4675    /// immediately.",
4676    ///      "type": "boolean"
4677    ///    },
4678    ///    "_group": {
4679    ///      "description": "Assign the request to a custom stats group.",
4680    ///      "type": "string"
4681    ///    }
4682    ///  }
4683    ///}
4684    /// ```
4685    /// </details>
4686    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4687    pub struct CoreMemstatsRequest {
4688        ///Run the command asynchronously. Returns a job id immediately.
4689        #[serde(
4690            rename = "_async",
4691            default,
4692            skip_serializing_if = "::std::option::Option::is_none"
4693        )]
4694        pub async_: ::std::option::Option<bool>,
4695        ///Assign the request to a custom stats group.
4696        #[serde(
4697            rename = "_group",
4698            default,
4699            skip_serializing_if = "::std::option::Option::is_none"
4700        )]
4701        pub group: ::std::option::Option<::std::string::String>,
4702    }
4703
4704    impl ::std::convert::From<&CoreMemstatsRequest> for CoreMemstatsRequest {
4705        fn from(value: &CoreMemstatsRequest) -> Self {
4706            value.clone()
4707        }
4708    }
4709
4710    impl ::std::default::Default for CoreMemstatsRequest {
4711        fn default() -> Self {
4712            Self {
4713                async_: Default::default(),
4714                group: Default::default(),
4715            }
4716        }
4717    }
4718
4719    ///`CoreObscurePrefer`
4720    ///
4721    /// <details><summary>JSON schema</summary>
4722    ///
4723    /// ```json
4724    ///{
4725    ///  "type": "string",
4726    ///  "enum": [
4727    ///    "respond-async"
4728    ///  ]
4729    ///}
4730    /// ```
4731    /// </details>
4732    #[derive(
4733        :: serde :: Deserialize,
4734        :: serde :: Serialize,
4735        Clone,
4736        Copy,
4737        Debug,
4738        Eq,
4739        Hash,
4740        Ord,
4741        PartialEq,
4742        PartialOrd,
4743    )]
4744    pub enum CoreObscurePrefer {
4745        #[serde(rename = "respond-async")]
4746        RespondAsync,
4747    }
4748
4749    impl ::std::convert::From<&Self> for CoreObscurePrefer {
4750        fn from(value: &CoreObscurePrefer) -> Self {
4751            value.clone()
4752        }
4753    }
4754
4755    impl ::std::fmt::Display for CoreObscurePrefer {
4756        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4757            match *self {
4758                Self::RespondAsync => f.write_str("respond-async"),
4759            }
4760        }
4761    }
4762
4763    impl ::std::str::FromStr for CoreObscurePrefer {
4764        type Err = self::error::ConversionError;
4765        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4766            match value {
4767                "respond-async" => Ok(Self::RespondAsync),
4768                _ => Err("invalid value".into()),
4769            }
4770        }
4771    }
4772
4773    impl ::std::convert::TryFrom<&str> for CoreObscurePrefer {
4774        type Error = self::error::ConversionError;
4775        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4776            value.parse()
4777        }
4778    }
4779
4780    impl ::std::convert::TryFrom<&::std::string::String> for CoreObscurePrefer {
4781        type Error = self::error::ConversionError;
4782        fn try_from(
4783            value: &::std::string::String,
4784        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4785            value.parse()
4786        }
4787    }
4788
4789    impl ::std::convert::TryFrom<::std::string::String> for CoreObscurePrefer {
4790        type Error = self::error::ConversionError;
4791        fn try_from(
4792            value: ::std::string::String,
4793        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4794            value.parse()
4795        }
4796    }
4797
4798    ///`CoreObscureRequest`
4799    ///
4800    /// <details><summary>JSON schema</summary>
4801    ///
4802    /// ```json
4803    ///{
4804    ///  "type": "object",
4805    ///  "properties": {
4806    ///    "_async": {
4807    ///      "description": "Run the command asynchronously. Returns a job id
4808    /// immediately.",
4809    ///      "type": "boolean"
4810    ///    },
4811    ///    "_group": {
4812    ///      "description": "Assign the request to a custom stats group.",
4813    ///      "type": "string"
4814    ///    },
4815    ///    "clear": {
4816    ///      "description": "Plain-text string to obscure for storage in the
4817    /// config file.",
4818    ///      "type": "string"
4819    ///    }
4820    ///  }
4821    ///}
4822    /// ```
4823    /// </details>
4824    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4825    pub struct CoreObscureRequest {
4826        ///Run the command asynchronously. Returns a job id immediately.
4827        #[serde(
4828            rename = "_async",
4829            default,
4830            skip_serializing_if = "::std::option::Option::is_none"
4831        )]
4832        pub async_: ::std::option::Option<bool>,
4833        ///Plain-text string to obscure for storage in the config file.
4834        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4835        pub clear: ::std::option::Option<::std::string::String>,
4836        ///Assign the request to a custom stats group.
4837        #[serde(
4838            rename = "_group",
4839            default,
4840            skip_serializing_if = "::std::option::Option::is_none"
4841        )]
4842        pub group: ::std::option::Option<::std::string::String>,
4843    }
4844
4845    impl ::std::convert::From<&CoreObscureRequest> for CoreObscureRequest {
4846        fn from(value: &CoreObscureRequest) -> Self {
4847            value.clone()
4848        }
4849    }
4850
4851    impl ::std::default::Default for CoreObscureRequest {
4852        fn default() -> Self {
4853            Self {
4854                async_: Default::default(),
4855                clear: Default::default(),
4856                group: Default::default(),
4857            }
4858        }
4859    }
4860
4861    ///`CoreObscureResponse`
4862    ///
4863    /// <details><summary>JSON schema</summary>
4864    ///
4865    /// ```json
4866    ///{
4867    ///  "type": "object",
4868    ///  "required": [
4869    ///    "obscured"
4870    ///  ],
4871    ///  "properties": {
4872    ///    "obscured": {
4873    ///      "type": "string"
4874    ///    }
4875    ///  }
4876    ///}
4877    /// ```
4878    /// </details>
4879    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4880    pub struct CoreObscureResponse {
4881        pub obscured: ::std::string::String,
4882    }
4883
4884    impl ::std::convert::From<&CoreObscureResponse> for CoreObscureResponse {
4885        fn from(value: &CoreObscureResponse) -> Self {
4886            value.clone()
4887        }
4888    }
4889
4890    ///`CorePidPrefer`
4891    ///
4892    /// <details><summary>JSON schema</summary>
4893    ///
4894    /// ```json
4895    ///{
4896    ///  "type": "string",
4897    ///  "enum": [
4898    ///    "respond-async"
4899    ///  ]
4900    ///}
4901    /// ```
4902    /// </details>
4903    #[derive(
4904        :: serde :: Deserialize,
4905        :: serde :: Serialize,
4906        Clone,
4907        Copy,
4908        Debug,
4909        Eq,
4910        Hash,
4911        Ord,
4912        PartialEq,
4913        PartialOrd,
4914    )]
4915    pub enum CorePidPrefer {
4916        #[serde(rename = "respond-async")]
4917        RespondAsync,
4918    }
4919
4920    impl ::std::convert::From<&Self> for CorePidPrefer {
4921        fn from(value: &CorePidPrefer) -> Self {
4922            value.clone()
4923        }
4924    }
4925
4926    impl ::std::fmt::Display for CorePidPrefer {
4927        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4928            match *self {
4929                Self::RespondAsync => f.write_str("respond-async"),
4930            }
4931        }
4932    }
4933
4934    impl ::std::str::FromStr for CorePidPrefer {
4935        type Err = self::error::ConversionError;
4936        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4937            match value {
4938                "respond-async" => Ok(Self::RespondAsync),
4939                _ => Err("invalid value".into()),
4940            }
4941        }
4942    }
4943
4944    impl ::std::convert::TryFrom<&str> for CorePidPrefer {
4945        type Error = self::error::ConversionError;
4946        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4947            value.parse()
4948        }
4949    }
4950
4951    impl ::std::convert::TryFrom<&::std::string::String> for CorePidPrefer {
4952        type Error = self::error::ConversionError;
4953        fn try_from(
4954            value: &::std::string::String,
4955        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4956            value.parse()
4957        }
4958    }
4959
4960    impl ::std::convert::TryFrom<::std::string::String> for CorePidPrefer {
4961        type Error = self::error::ConversionError;
4962        fn try_from(
4963            value: ::std::string::String,
4964        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4965            value.parse()
4966        }
4967    }
4968
4969    ///`CorePidRequest`
4970    ///
4971    /// <details><summary>JSON schema</summary>
4972    ///
4973    /// ```json
4974    ///{
4975    ///  "type": "object",
4976    ///  "properties": {
4977    ///    "_async": {
4978    ///      "description": "Run the command asynchronously. Returns a job id
4979    /// immediately.",
4980    ///      "type": "boolean"
4981    ///    },
4982    ///    "_group": {
4983    ///      "description": "Assign the request to a custom stats group.",
4984    ///      "type": "string"
4985    ///    }
4986    ///  }
4987    ///}
4988    /// ```
4989    /// </details>
4990    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4991    pub struct CorePidRequest {
4992        ///Run the command asynchronously. Returns a job id immediately.
4993        #[serde(
4994            rename = "_async",
4995            default,
4996            skip_serializing_if = "::std::option::Option::is_none"
4997        )]
4998        pub async_: ::std::option::Option<bool>,
4999        ///Assign the request to a custom stats group.
5000        #[serde(
5001            rename = "_group",
5002            default,
5003            skip_serializing_if = "::std::option::Option::is_none"
5004        )]
5005        pub group: ::std::option::Option<::std::string::String>,
5006    }
5007
5008    impl ::std::convert::From<&CorePidRequest> for CorePidRequest {
5009        fn from(value: &CorePidRequest) -> Self {
5010            value.clone()
5011        }
5012    }
5013
5014    impl ::std::default::Default for CorePidRequest {
5015        fn default() -> Self {
5016            Self {
5017                async_: Default::default(),
5018                group: Default::default(),
5019            }
5020        }
5021    }
5022
5023    ///`CorePidResponse`
5024    ///
5025    /// <details><summary>JSON schema</summary>
5026    ///
5027    /// ```json
5028    ///{
5029    ///  "type": "object",
5030    ///  "required": [
5031    ///    "pid"
5032    ///  ],
5033    ///  "properties": {
5034    ///    "pid": {
5035    ///      "type": "integer"
5036    ///    }
5037    ///  }
5038    ///}
5039    /// ```
5040    /// </details>
5041    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5042    pub struct CorePidResponse {
5043        pub pid: i64,
5044    }
5045
5046    impl ::std::convert::From<&CorePidResponse> for CorePidResponse {
5047        fn from(value: &CorePidResponse) -> Self {
5048            value.clone()
5049        }
5050    }
5051
5052    ///`CoreQuitPrefer`
5053    ///
5054    /// <details><summary>JSON schema</summary>
5055    ///
5056    /// ```json
5057    ///{
5058    ///  "type": "string",
5059    ///  "enum": [
5060    ///    "respond-async"
5061    ///  ]
5062    ///}
5063    /// ```
5064    /// </details>
5065    #[derive(
5066        :: serde :: Deserialize,
5067        :: serde :: Serialize,
5068        Clone,
5069        Copy,
5070        Debug,
5071        Eq,
5072        Hash,
5073        Ord,
5074        PartialEq,
5075        PartialOrd,
5076    )]
5077    pub enum CoreQuitPrefer {
5078        #[serde(rename = "respond-async")]
5079        RespondAsync,
5080    }
5081
5082    impl ::std::convert::From<&Self> for CoreQuitPrefer {
5083        fn from(value: &CoreQuitPrefer) -> Self {
5084            value.clone()
5085        }
5086    }
5087
5088    impl ::std::fmt::Display for CoreQuitPrefer {
5089        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5090            match *self {
5091                Self::RespondAsync => f.write_str("respond-async"),
5092            }
5093        }
5094    }
5095
5096    impl ::std::str::FromStr for CoreQuitPrefer {
5097        type Err = self::error::ConversionError;
5098        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5099            match value {
5100                "respond-async" => Ok(Self::RespondAsync),
5101                _ => Err("invalid value".into()),
5102            }
5103        }
5104    }
5105
5106    impl ::std::convert::TryFrom<&str> for CoreQuitPrefer {
5107        type Error = self::error::ConversionError;
5108        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5109            value.parse()
5110        }
5111    }
5112
5113    impl ::std::convert::TryFrom<&::std::string::String> for CoreQuitPrefer {
5114        type Error = self::error::ConversionError;
5115        fn try_from(
5116            value: &::std::string::String,
5117        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5118            value.parse()
5119        }
5120    }
5121
5122    impl ::std::convert::TryFrom<::std::string::String> for CoreQuitPrefer {
5123        type Error = self::error::ConversionError;
5124        fn try_from(
5125            value: ::std::string::String,
5126        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5127            value.parse()
5128        }
5129    }
5130
5131    ///`CoreQuitRequest`
5132    ///
5133    /// <details><summary>JSON schema</summary>
5134    ///
5135    /// ```json
5136    ///{
5137    ///  "type": "object",
5138    ///  "properties": {
5139    ///    "_async": {
5140    ///      "description": "Run the command asynchronously. Returns a job id
5141    /// immediately.",
5142    ///      "type": "boolean"
5143    ///    },
5144    ///    "_group": {
5145    ///      "description": "Assign the request to a custom stats group.",
5146    ///      "type": "string"
5147    ///    },
5148    ///    "exitCode": {
5149    ///      "description": "Optional exit code to use when terminating the
5150    /// rclone process.",
5151    ///      "type": "integer"
5152    ///    }
5153    ///  }
5154    ///}
5155    /// ```
5156    /// </details>
5157    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5158    pub struct CoreQuitRequest {
5159        ///Run the command asynchronously. Returns a job id immediately.
5160        #[serde(
5161            rename = "_async",
5162            default,
5163            skip_serializing_if = "::std::option::Option::is_none"
5164        )]
5165        pub async_: ::std::option::Option<bool>,
5166        ///Optional exit code to use when terminating the rclone process.
5167        #[serde(
5168            rename = "exitCode",
5169            default,
5170            skip_serializing_if = "::std::option::Option::is_none"
5171        )]
5172        pub exit_code: ::std::option::Option<i64>,
5173        ///Assign the request to a custom stats group.
5174        #[serde(
5175            rename = "_group",
5176            default,
5177            skip_serializing_if = "::std::option::Option::is_none"
5178        )]
5179        pub group: ::std::option::Option<::std::string::String>,
5180    }
5181
5182    impl ::std::convert::From<&CoreQuitRequest> for CoreQuitRequest {
5183        fn from(value: &CoreQuitRequest) -> Self {
5184            value.clone()
5185        }
5186    }
5187
5188    impl ::std::default::Default for CoreQuitRequest {
5189        fn default() -> Self {
5190            Self {
5191                async_: Default::default(),
5192                exit_code: Default::default(),
5193                group: Default::default(),
5194            }
5195        }
5196    }
5197
5198    ///Metadata for an item currently undergoing verification.
5199    ///
5200    /// <details><summary>JSON schema</summary>
5201    ///
5202    /// ```json
5203    ///{
5204    ///  "description": "Metadata for an item currently undergoing
5205    /// verification.",
5206    ///  "type": "object",
5207    ///  "properties": {
5208    ///    "group": {
5209    ///      "description": "Stats group name associated with this
5210    /// verification.",
5211    ///      "type": "string"
5212    ///    },
5213    ///    "name": {
5214    ///      "description": "Remote path of the object being verified.",
5215    ///      "type": "string"
5216    ///    },
5217    ///    "size": {
5218    ///      "description": "Total size in bytes of the object.",
5219    ///      "type": "number"
5220    ///    }
5221    ///  },
5222    ///  "additionalProperties": true
5223    ///}
5224    /// ```
5225    /// </details>
5226    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5227    pub struct CoreStatsChecking {
5228        ///Stats group name associated with this verification.
5229        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5230        pub group: ::std::option::Option<::std::string::String>,
5231        ///Remote path of the object being verified.
5232        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5233        pub name: ::std::option::Option<::std::string::String>,
5234        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5235        pub size: ::std::option::Option<f64>,
5236    }
5237
5238    impl ::std::convert::From<&CoreStatsChecking> for CoreStatsChecking {
5239        fn from(value: &CoreStatsChecking) -> Self {
5240            value.clone()
5241        }
5242    }
5243
5244    impl ::std::default::Default for CoreStatsChecking {
5245        fn default() -> Self {
5246            Self {
5247                group: Default::default(),
5248                name: Default::default(),
5249                size: Default::default(),
5250            }
5251        }
5252    }
5253
5254    ///`CoreStatsDeletePrefer`
5255    ///
5256    /// <details><summary>JSON schema</summary>
5257    ///
5258    /// ```json
5259    ///{
5260    ///  "type": "string",
5261    ///  "enum": [
5262    ///    "respond-async"
5263    ///  ]
5264    ///}
5265    /// ```
5266    /// </details>
5267    #[derive(
5268        :: serde :: Deserialize,
5269        :: serde :: Serialize,
5270        Clone,
5271        Copy,
5272        Debug,
5273        Eq,
5274        Hash,
5275        Ord,
5276        PartialEq,
5277        PartialOrd,
5278    )]
5279    pub enum CoreStatsDeletePrefer {
5280        #[serde(rename = "respond-async")]
5281        RespondAsync,
5282    }
5283
5284    impl ::std::convert::From<&Self> for CoreStatsDeletePrefer {
5285        fn from(value: &CoreStatsDeletePrefer) -> Self {
5286            value.clone()
5287        }
5288    }
5289
5290    impl ::std::fmt::Display for CoreStatsDeletePrefer {
5291        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5292            match *self {
5293                Self::RespondAsync => f.write_str("respond-async"),
5294            }
5295        }
5296    }
5297
5298    impl ::std::str::FromStr for CoreStatsDeletePrefer {
5299        type Err = self::error::ConversionError;
5300        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5301            match value {
5302                "respond-async" => Ok(Self::RespondAsync),
5303                _ => Err("invalid value".into()),
5304            }
5305        }
5306    }
5307
5308    impl ::std::convert::TryFrom<&str> for CoreStatsDeletePrefer {
5309        type Error = self::error::ConversionError;
5310        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5311            value.parse()
5312        }
5313    }
5314
5315    impl ::std::convert::TryFrom<&::std::string::String> for CoreStatsDeletePrefer {
5316        type Error = self::error::ConversionError;
5317        fn try_from(
5318            value: &::std::string::String,
5319        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5320            value.parse()
5321        }
5322    }
5323
5324    impl ::std::convert::TryFrom<::std::string::String> for CoreStatsDeletePrefer {
5325        type Error = self::error::ConversionError;
5326        fn try_from(
5327            value: ::std::string::String,
5328        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5329            value.parse()
5330        }
5331    }
5332
5333    ///`CoreStatsDeleteRequest`
5334    ///
5335    /// <details><summary>JSON schema</summary>
5336    ///
5337    /// ```json
5338    ///{
5339    ///  "type": "object",
5340    ///  "properties": {
5341    ///    "_async": {
5342    ///      "description": "Run the command asynchronously. Returns a job id
5343    /// immediately.",
5344    ///      "type": "boolean"
5345    ///    },
5346    ///    "_group": {
5347    ///      "description": "Assign the request to a custom stats group.",
5348    ///      "type": "string"
5349    ///    },
5350    ///    "group": {
5351    ///      "description": "Stats group identifier to remove.",
5352    ///      "type": "string"
5353    ///    }
5354    ///  }
5355    ///}
5356    /// ```
5357    /// </details>
5358    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5359    pub struct CoreStatsDeleteRequest {
5360        ///Run the command asynchronously. Returns a job id immediately.
5361        #[serde(
5362            rename = "_async",
5363            default,
5364            skip_serializing_if = "::std::option::Option::is_none"
5365        )]
5366        pub async_: ::std::option::Option<bool>,
5367        ///Assign the request to a custom stats group.
5368        #[serde(
5369            rename = "_group",
5370            default,
5371            skip_serializing_if = "::std::option::Option::is_none"
5372        )]
5373        pub group_: ::std::option::Option<::std::string::String>,
5374        ///Stats group identifier to remove.
5375        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5376        pub group: ::std::option::Option<::std::string::String>,
5377    }
5378
5379    impl ::std::convert::From<&CoreStatsDeleteRequest> for CoreStatsDeleteRequest {
5380        fn from(value: &CoreStatsDeleteRequest) -> Self {
5381            value.clone()
5382        }
5383    }
5384
5385    impl ::std::default::Default for CoreStatsDeleteRequest {
5386        fn default() -> Self {
5387            Self {
5388                async_: Default::default(),
5389                group_: Default::default(),
5390                group: Default::default(),
5391            }
5392        }
5393    }
5394
5395    ///`CoreStatsPrefer`
5396    ///
5397    /// <details><summary>JSON schema</summary>
5398    ///
5399    /// ```json
5400    ///{
5401    ///  "type": "string",
5402    ///  "enum": [
5403    ///    "respond-async"
5404    ///  ]
5405    ///}
5406    /// ```
5407    /// </details>
5408    #[derive(
5409        :: serde :: Deserialize,
5410        :: serde :: Serialize,
5411        Clone,
5412        Copy,
5413        Debug,
5414        Eq,
5415        Hash,
5416        Ord,
5417        PartialEq,
5418        PartialOrd,
5419    )]
5420    pub enum CoreStatsPrefer {
5421        #[serde(rename = "respond-async")]
5422        RespondAsync,
5423    }
5424
5425    impl ::std::convert::From<&Self> for CoreStatsPrefer {
5426        fn from(value: &CoreStatsPrefer) -> Self {
5427            value.clone()
5428        }
5429    }
5430
5431    impl ::std::fmt::Display for CoreStatsPrefer {
5432        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5433            match *self {
5434                Self::RespondAsync => f.write_str("respond-async"),
5435            }
5436        }
5437    }
5438
5439    impl ::std::str::FromStr for CoreStatsPrefer {
5440        type Err = self::error::ConversionError;
5441        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5442            match value {
5443                "respond-async" => Ok(Self::RespondAsync),
5444                _ => Err("invalid value".into()),
5445            }
5446        }
5447    }
5448
5449    impl ::std::convert::TryFrom<&str> for CoreStatsPrefer {
5450        type Error = self::error::ConversionError;
5451        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5452            value.parse()
5453        }
5454    }
5455
5456    impl ::std::convert::TryFrom<&::std::string::String> for CoreStatsPrefer {
5457        type Error = self::error::ConversionError;
5458        fn try_from(
5459            value: &::std::string::String,
5460        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5461            value.parse()
5462        }
5463    }
5464
5465    impl ::std::convert::TryFrom<::std::string::String> for CoreStatsPrefer {
5466        type Error = self::error::ConversionError;
5467        fn try_from(
5468            value: ::std::string::String,
5469        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5470            value.parse()
5471        }
5472    }
5473
5474    ///`CoreStatsRequest`
5475    ///
5476    /// <details><summary>JSON schema</summary>
5477    ///
5478    /// ```json
5479    ///{
5480    ///  "type": "object",
5481    ///  "properties": {
5482    ///    "_async": {
5483    ///      "description": "Run the command asynchronously. Returns a job id
5484    /// immediately.",
5485    ///      "type": "boolean"
5486    ///    },
5487    ///    "_group": {
5488    ///      "description": "Assign the request to a custom stats group.",
5489    ///      "type": "string"
5490    ///    },
5491    ///    "group": {
5492    ///      "description": "Stats group identifier to return a snapshot for.
5493    /// Leave unset to include all groups.",
5494    ///      "type": "string"
5495    ///    },
5496    ///    "short": {
5497    ///      "description": "When true, omit the `transferring` and `checking`
5498    /// arrays from the response.",
5499    ///      "type": "boolean"
5500    ///    }
5501    ///  }
5502    ///}
5503    /// ```
5504    /// </details>
5505    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5506    pub struct CoreStatsRequest {
5507        ///Run the command asynchronously. Returns a job id immediately.
5508        #[serde(
5509            rename = "_async",
5510            default,
5511            skip_serializing_if = "::std::option::Option::is_none"
5512        )]
5513        pub async_: ::std::option::Option<bool>,
5514        ///Assign the request to a custom stats group.
5515        #[serde(
5516            rename = "_group",
5517            default,
5518            skip_serializing_if = "::std::option::Option::is_none"
5519        )]
5520        pub group_: ::std::option::Option<::std::string::String>,
5521        ///Stats group identifier to return a snapshot for. Leave unset to
5522        /// include all groups.
5523        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5524        pub group: ::std::option::Option<::std::string::String>,
5525        ///When true, omit the `transferring` and `checking` arrays from the
5526        /// response.
5527        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5528        pub short: ::std::option::Option<bool>,
5529    }
5530
5531    impl ::std::convert::From<&CoreStatsRequest> for CoreStatsRequest {
5532        fn from(value: &CoreStatsRequest) -> Self {
5533            value.clone()
5534        }
5535    }
5536
5537    impl ::std::default::Default for CoreStatsRequest {
5538        fn default() -> Self {
5539            Self {
5540                async_: Default::default(),
5541                group_: Default::default(),
5542                group: Default::default(),
5543                short: Default::default(),
5544            }
5545        }
5546    }
5547
5548    ///`CoreStatsResetPrefer`
5549    ///
5550    /// <details><summary>JSON schema</summary>
5551    ///
5552    /// ```json
5553    ///{
5554    ///  "type": "string",
5555    ///  "enum": [
5556    ///    "respond-async"
5557    ///  ]
5558    ///}
5559    /// ```
5560    /// </details>
5561    #[derive(
5562        :: serde :: Deserialize,
5563        :: serde :: Serialize,
5564        Clone,
5565        Copy,
5566        Debug,
5567        Eq,
5568        Hash,
5569        Ord,
5570        PartialEq,
5571        PartialOrd,
5572    )]
5573    pub enum CoreStatsResetPrefer {
5574        #[serde(rename = "respond-async")]
5575        RespondAsync,
5576    }
5577
5578    impl ::std::convert::From<&Self> for CoreStatsResetPrefer {
5579        fn from(value: &CoreStatsResetPrefer) -> Self {
5580            value.clone()
5581        }
5582    }
5583
5584    impl ::std::fmt::Display for CoreStatsResetPrefer {
5585        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5586            match *self {
5587                Self::RespondAsync => f.write_str("respond-async"),
5588            }
5589        }
5590    }
5591
5592    impl ::std::str::FromStr for CoreStatsResetPrefer {
5593        type Err = self::error::ConversionError;
5594        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5595            match value {
5596                "respond-async" => Ok(Self::RespondAsync),
5597                _ => Err("invalid value".into()),
5598            }
5599        }
5600    }
5601
5602    impl ::std::convert::TryFrom<&str> for CoreStatsResetPrefer {
5603        type Error = self::error::ConversionError;
5604        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
5605            value.parse()
5606        }
5607    }
5608
5609    impl ::std::convert::TryFrom<&::std::string::String> for CoreStatsResetPrefer {
5610        type Error = self::error::ConversionError;
5611        fn try_from(
5612            value: &::std::string::String,
5613        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5614            value.parse()
5615        }
5616    }
5617
5618    impl ::std::convert::TryFrom<::std::string::String> for CoreStatsResetPrefer {
5619        type Error = self::error::ConversionError;
5620        fn try_from(
5621            value: ::std::string::String,
5622        ) -> ::std::result::Result<Self, self::error::ConversionError> {
5623            value.parse()
5624        }
5625    }
5626
5627    ///`CoreStatsResetRequest`
5628    ///
5629    /// <details><summary>JSON schema</summary>
5630    ///
5631    /// ```json
5632    ///{
5633    ///  "type": "object",
5634    ///  "properties": {
5635    ///    "_async": {
5636    ///      "description": "Run the command asynchronously. Returns a job id
5637    /// immediately.",
5638    ///      "type": "boolean"
5639    ///    },
5640    ///    "_group": {
5641    ///      "description": "Assign the request to a custom stats group.",
5642    ///      "type": "string"
5643    ///    },
5644    ///    "group": {
5645    ///      "description": "Stats group identifier whose counters should be
5646    /// reset. Leave unset to reset all groups.",
5647    ///      "type": "string"
5648    ///    }
5649    ///  }
5650    ///}
5651    /// ```
5652    /// </details>
5653    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5654    pub struct CoreStatsResetRequest {
5655        ///Run the command asynchronously. Returns a job id immediately.
5656        #[serde(
5657            rename = "_async",
5658            default,
5659            skip_serializing_if = "::std::option::Option::is_none"
5660        )]
5661        pub async_: ::std::option::Option<bool>,
5662        ///Assign the request to a custom stats group.
5663        #[serde(
5664            rename = "_group",
5665            default,
5666            skip_serializing_if = "::std::option::Option::is_none"
5667        )]
5668        pub group_: ::std::option::Option<::std::string::String>,
5669        ///Stats group identifier whose counters should be reset. Leave unset
5670        /// to reset all groups.
5671        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5672        pub group: ::std::option::Option<::std::string::String>,
5673    }
5674
5675    impl ::std::convert::From<&CoreStatsResetRequest> for CoreStatsResetRequest {
5676        fn from(value: &CoreStatsResetRequest) -> Self {
5677            value.clone()
5678        }
5679    }
5680
5681    impl ::std::default::Default for CoreStatsResetRequest {
5682        fn default() -> Self {
5683            Self {
5684                async_: Default::default(),
5685                group_: Default::default(),
5686                group: Default::default(),
5687            }
5688        }
5689    }
5690
5691    ///`CoreStatsResponse`
5692    ///
5693    /// <details><summary>JSON schema</summary>
5694    ///
5695    /// ```json
5696    ///{
5697    ///  "type": "object",
5698    ///  "required": [
5699    ///    "bytes",
5700    ///    "checks",
5701    ///    "deletedDirs",
5702    ///    "deletes",
5703    ///    "elapsedTime",
5704    ///    "errors",
5705    ///    "fatalError",
5706    ///    "renames",
5707    ///    "retryError",
5708    ///    "serverSideCopies",
5709    ///    "serverSideCopyBytes",
5710    ///    "serverSideMoveBytes",
5711    ///    "serverSideMoves",
5712    ///    "speed",
5713    ///    "totalBytes",
5714    ///    "totalChecks",
5715    ///    "totalTransfers",
5716    ///    "transferTime",
5717    ///    "transfers"
5718    ///  ],
5719    ///  "properties": {
5720    ///    "bytes": {
5721    ///      "type": "number"
5722    ///    },
5723    ///    "checking": {
5724    ///      "description": "Objects currently undergoing verification
5725    /// operations.",
5726    ///      "type": "array",
5727    ///      "items": {
5728    ///        "$ref": "#/components/schemas/CoreStatsChecking"
5729    ///      }
5730    ///    },
5731    ///    "checks": {
5732    ///      "type": "number"
5733    ///    },
5734    ///    "deletedDirs": {
5735    ///      "type": "number"
5736    ///    },
5737    ///    "deletes": {
5738    ///      "type": "number"
5739    ///    },
5740    ///    "elapsedTime": {
5741    ///      "type": "number"
5742    ///    },
5743    ///    "errors": {
5744    ///      "type": "number"
5745    ///    },
5746    ///    "eta": {
5747    ///      "type": [
5748    ///        "number",
5749    ///        "null"
5750    ///      ]
5751    ///    },
5752    ///    "fatalError": {
5753    ///      "type": "boolean"
5754    ///    },
5755    ///    "lastError": {
5756    ///      "type": "string"
5757    ///    },
5758    ///    "listed": {
5759    ///      "type": "number"
5760    ///    },
5761    ///    "renames": {
5762    ///      "type": "number"
5763    ///    },
5764    ///    "retryError": {
5765    ///      "type": "boolean"
5766    ///    },
5767    ///    "serverSideCopies": {
5768    ///      "type": "number"
5769    ///    },
5770    ///    "serverSideCopyBytes": {
5771    ///      "type": "number"
5772    ///    },
5773    ///    "serverSideMoveBytes": {
5774    ///      "type": "number"
5775    ///    },
5776    ///    "serverSideMoves": {
5777    ///      "type": "number"
5778    ///    },
5779    ///    "speed": {
5780    ///      "type": "number"
5781    ///    },
5782    ///    "totalBytes": {
5783    ///      "type": "number"
5784    ///    },
5785    ///    "totalChecks": {
5786    ///      "type": "number"
5787    ///    },
5788    ///    "totalTransfers": {
5789    ///      "type": "number"
5790    ///    },
5791    ///    "transferTime": {
5792    ///      "type": "number"
5793    ///    },
5794    ///    "transferring": {
5795    ///      "description": "Active transfers currently in progress grouped by
5796    /// stats group.",
5797    ///      "type": "array",
5798    ///      "items": {
5799    ///        "$ref": "#/components/schemas/CoreStatsTransfer"
5800    ///      }
5801    ///    },
5802    ///    "transfers": {
5803    ///      "type": "number"
5804    ///    }
5805    ///  }
5806    ///}
5807    /// ```
5808    /// </details>
5809    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5810    pub struct CoreStatsResponse {
5811        pub bytes: f64,
5812        ///Objects currently undergoing verification operations.
5813        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
5814        pub checking: ::std::vec::Vec<CoreStatsChecking>,
5815        pub checks: f64,
5816        #[serde(rename = "deletedDirs")]
5817        pub deleted_dirs: f64,
5818        pub deletes: f64,
5819        #[serde(rename = "elapsedTime")]
5820        pub elapsed_time: f64,
5821        pub errors: f64,
5822        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5823        pub eta: ::std::option::Option<f64>,
5824        #[serde(rename = "fatalError")]
5825        pub fatal_error: bool,
5826        #[serde(
5827            rename = "lastError",
5828            default,
5829            skip_serializing_if = "::std::option::Option::is_none"
5830        )]
5831        pub last_error: ::std::option::Option<::std::string::String>,
5832        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5833        pub listed: ::std::option::Option<f64>,
5834        pub renames: f64,
5835        #[serde(rename = "retryError")]
5836        pub retry_error: bool,
5837        #[serde(rename = "serverSideCopies")]
5838        pub server_side_copies: f64,
5839        #[serde(rename = "serverSideCopyBytes")]
5840        pub server_side_copy_bytes: f64,
5841        #[serde(rename = "serverSideMoveBytes")]
5842        pub server_side_move_bytes: f64,
5843        #[serde(rename = "serverSideMoves")]
5844        pub server_side_moves: f64,
5845        pub speed: f64,
5846        #[serde(rename = "totalBytes")]
5847        pub total_bytes: f64,
5848        #[serde(rename = "totalChecks")]
5849        pub total_checks: f64,
5850        #[serde(rename = "totalTransfers")]
5851        pub total_transfers: f64,
5852        #[serde(rename = "transferTime")]
5853        pub transfer_time: f64,
5854        ///Active transfers currently in progress grouped by stats group.
5855        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
5856        pub transferring: ::std::vec::Vec<CoreStatsTransfer>,
5857        pub transfers: f64,
5858    }
5859
5860    impl ::std::convert::From<&CoreStatsResponse> for CoreStatsResponse {
5861        fn from(value: &CoreStatsResponse) -> Self {
5862            value.clone()
5863        }
5864    }
5865
5866    ///Progress metrics for an in-flight transfer.
5867    ///
5868    /// <details><summary>JSON schema</summary>
5869    ///
5870    /// ```json
5871    ///{
5872    ///  "description": "Progress metrics for an in-flight transfer.",
5873    ///  "type": "object",
5874    ///  "properties": {
5875    ///    "bytes": {
5876    ///      "description": "Bytes transferred so far for this object.",
5877    ///      "type": "number"
5878    ///    },
5879    ///    "dstFs": {
5880    ///      "description": "Destination remote or filesystem for this
5881    /// transfer.",
5882    ///      "type": "string"
5883    ///    },
5884    ///    "dstRemote": {
5885    ///      "description": "Destination path within dstFs.",
5886    ///      "type": "string"
5887    ///    },
5888    ///    "eta": {
5889    ///      "description": "Estimated seconds remaining, when available.",
5890    ///      "type": [
5891    ///        "number",
5892    ///        "null"
5893    ///      ]
5894    ///    },
5895    ///    "group": {
5896    ///      "description": "Stats group name associated with this transfer.",
5897    ///      "type": "string"
5898    ///    },
5899    ///    "name": {
5900    ///      "description": "Remote path of the object being transferred.",
5901    ///      "type": "string"
5902    ///    },
5903    ///    "percentage": {
5904    ///      "description": "Completion percentage from 0-100.",
5905    ///      "type": "number"
5906    ///    },
5907    ///    "size": {
5908    ///      "description": "Total size in bytes of the object.",
5909    ///      "type": "number"
5910    ///    },
5911    ///    "speed": {
5912    ///      "description": "Current transfer speed in bytes per second.",
5913    ///      "type": "number"
5914    ///    },
5915    ///    "speedAvg": {
5916    ///      "description": "Current speed in bytes per second as an
5917    /// exponentially weighted moving average.",
5918    ///      "type": "number"
5919    ///    },
5920    ///    "srcFs": {
5921    ///      "description": "Source remote or filesystem for this transfer.",
5922    ///      "type": "string"
5923    ///    },
5924    ///    "srcRemote": {
5925    ///      "description": "Source path within srcFs.",
5926    ///      "type": "string"
5927    ///    }
5928    ///  },
5929    ///  "additionalProperties": true
5930    ///}
5931    /// ```
5932    /// </details>
5933    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5934    pub struct CoreStatsTransfer {
5935        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5936        pub bytes: ::std::option::Option<f64>,
5937        ///Destination remote or filesystem for this transfer.
5938        #[serde(
5939            rename = "dstFs",
5940            default,
5941            skip_serializing_if = "::std::option::Option::is_none"
5942        )]
5943        pub dst_fs: ::std::option::Option<::std::string::String>,
5944        ///Destination path within dstFs.
5945        #[serde(
5946            rename = "dstRemote",
5947            default,
5948            skip_serializing_if = "::std::option::Option::is_none"
5949        )]
5950        pub dst_remote: ::std::option::Option<::std::string::String>,
5951        ///Estimated seconds remaining, when available.
5952        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5953        pub eta: ::std::option::Option<f64>,
5954        ///Stats group name associated with this transfer.
5955        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5956        pub group: ::std::option::Option<::std::string::String>,
5957        ///Remote path of the object being transferred.
5958        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5959        pub name: ::std::option::Option<::std::string::String>,
5960        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5961        pub percentage: ::std::option::Option<f64>,
5962        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5963        pub size: ::std::option::Option<f64>,
5964        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5965        pub speed: ::std::option::Option<f64>,
5966        #[serde(
5967            rename = "speedAvg",
5968            default,
5969            skip_serializing_if = "::std::option::Option::is_none"
5970        )]
5971        pub speed_avg: ::std::option::Option<f64>,
5972        ///Source remote or filesystem for this transfer.
5973        #[serde(
5974            rename = "srcFs",
5975            default,
5976            skip_serializing_if = "::std::option::Option::is_none"
5977        )]
5978        pub src_fs: ::std::option::Option<::std::string::String>,
5979        ///Source path within srcFs.
5980        #[serde(
5981            rename = "srcRemote",
5982            default,
5983            skip_serializing_if = "::std::option::Option::is_none"
5984        )]
5985        pub src_remote: ::std::option::Option<::std::string::String>,
5986    }
5987
5988    impl ::std::convert::From<&CoreStatsTransfer> for CoreStatsTransfer {
5989        fn from(value: &CoreStatsTransfer) -> Self {
5990            value.clone()
5991        }
5992    }
5993
5994    impl ::std::default::Default for CoreStatsTransfer {
5995        fn default() -> Self {
5996            Self {
5997                bytes: Default::default(),
5998                dst_fs: Default::default(),
5999                dst_remote: Default::default(),
6000                eta: Default::default(),
6001                group: Default::default(),
6002                name: Default::default(),
6003                percentage: Default::default(),
6004                size: Default::default(),
6005                speed: Default::default(),
6006                speed_avg: Default::default(),
6007                src_fs: Default::default(),
6008                src_remote: Default::default(),
6009            }
6010        }
6011    }
6012
6013    ///`CoreTransferredPrefer`
6014    ///
6015    /// <details><summary>JSON schema</summary>
6016    ///
6017    /// ```json
6018    ///{
6019    ///  "type": "string",
6020    ///  "enum": [
6021    ///    "respond-async"
6022    ///  ]
6023    ///}
6024    /// ```
6025    /// </details>
6026    #[derive(
6027        :: serde :: Deserialize,
6028        :: serde :: Serialize,
6029        Clone,
6030        Copy,
6031        Debug,
6032        Eq,
6033        Hash,
6034        Ord,
6035        PartialEq,
6036        PartialOrd,
6037    )]
6038    pub enum CoreTransferredPrefer {
6039        #[serde(rename = "respond-async")]
6040        RespondAsync,
6041    }
6042
6043    impl ::std::convert::From<&Self> for CoreTransferredPrefer {
6044        fn from(value: &CoreTransferredPrefer) -> Self {
6045            value.clone()
6046        }
6047    }
6048
6049    impl ::std::fmt::Display for CoreTransferredPrefer {
6050        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6051            match *self {
6052                Self::RespondAsync => f.write_str("respond-async"),
6053            }
6054        }
6055    }
6056
6057    impl ::std::str::FromStr for CoreTransferredPrefer {
6058        type Err = self::error::ConversionError;
6059        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6060            match value {
6061                "respond-async" => Ok(Self::RespondAsync),
6062                _ => Err("invalid value".into()),
6063            }
6064        }
6065    }
6066
6067    impl ::std::convert::TryFrom<&str> for CoreTransferredPrefer {
6068        type Error = self::error::ConversionError;
6069        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6070            value.parse()
6071        }
6072    }
6073
6074    impl ::std::convert::TryFrom<&::std::string::String> for CoreTransferredPrefer {
6075        type Error = self::error::ConversionError;
6076        fn try_from(
6077            value: &::std::string::String,
6078        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6079            value.parse()
6080        }
6081    }
6082
6083    impl ::std::convert::TryFrom<::std::string::String> for CoreTransferredPrefer {
6084        type Error = self::error::ConversionError;
6085        fn try_from(
6086            value: ::std::string::String,
6087        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6088            value.parse()
6089        }
6090    }
6091
6092    ///`CoreTransferredRequest`
6093    ///
6094    /// <details><summary>JSON schema</summary>
6095    ///
6096    /// ```json
6097    ///{
6098    ///  "type": "object",
6099    ///  "properties": {
6100    ///    "_async": {
6101    ///      "description": "Run the command asynchronously. Returns a job id
6102    /// immediately.",
6103    ///      "type": "boolean"
6104    ///    },
6105    ///    "_group": {
6106    ///      "description": "Assign the request to a custom stats group.",
6107    ///      "type": "string"
6108    ///    },
6109    ///    "group": {
6110    ///      "description": "Stats group identifier to filter the completed
6111    /// transfer list. Leave unset for all groups.",
6112    ///      "type": "string"
6113    ///    }
6114    ///  }
6115    ///}
6116    /// ```
6117    /// </details>
6118    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6119    pub struct CoreTransferredRequest {
6120        ///Run the command asynchronously. Returns a job id immediately.
6121        #[serde(
6122            rename = "_async",
6123            default,
6124            skip_serializing_if = "::std::option::Option::is_none"
6125        )]
6126        pub async_: ::std::option::Option<bool>,
6127        ///Assign the request to a custom stats group.
6128        #[serde(
6129            rename = "_group",
6130            default,
6131            skip_serializing_if = "::std::option::Option::is_none"
6132        )]
6133        pub group_: ::std::option::Option<::std::string::String>,
6134        ///Stats group identifier to filter the completed transfer list. Leave
6135        /// unset for all groups.
6136        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6137        pub group: ::std::option::Option<::std::string::String>,
6138    }
6139
6140    impl ::std::convert::From<&CoreTransferredRequest> for CoreTransferredRequest {
6141        fn from(value: &CoreTransferredRequest) -> Self {
6142            value.clone()
6143        }
6144    }
6145
6146    impl ::std::default::Default for CoreTransferredRequest {
6147        fn default() -> Self {
6148            Self {
6149                async_: Default::default(),
6150                group_: Default::default(),
6151                group: Default::default(),
6152            }
6153        }
6154    }
6155
6156    ///`CoreTransferredResponse`
6157    ///
6158    /// <details><summary>JSON schema</summary>
6159    ///
6160    /// ```json
6161    ///{
6162    ///  "type": "object",
6163    ///  "required": [
6164    ///    "transferred"
6165    ///  ],
6166    ///  "properties": {
6167    ///    "transferred": {
6168    ///      "type": "array",
6169    ///      "items": {
6170    ///        "type": "object",
6171    ///        "required": [
6172    ///          "bytes",
6173    ///          "checked",
6174    ///          "completed_at",
6175    ///          "error",
6176    ///          "group",
6177    ///          "name",
6178    ///          "size",
6179    ///          "started_at",
6180    ///          "what"
6181    ///        ],
6182    ///        "properties": {
6183    ///          "bytes": {
6184    ///            "type": "integer"
6185    ///          },
6186    ///          "checked": {
6187    ///            "type": "boolean"
6188    ///          },
6189    ///          "completed_at": {
6190    ///            "description": "ISO8601 timestamp when the transfer
6191    /// completed.",
6192    ///            "type": "string"
6193    ///          },
6194    ///          "dstFs": {
6195    ///            "description": "Destination remote or filesystem used for the
6196    /// transfer.",
6197    ///            "type": "string"
6198    ///          },
6199    ///          "dstRemote": {
6200    ///            "description": "Destination path within `dstFs`, when
6201    /// provided.",
6202    ///            "type": "string"
6203    ///          },
6204    ///          "error": {
6205    ///            "type": "string"
6206    ///          },
6207    ///          "group": {
6208    ///            "description": "Stats group identifier this transfer belonged
6209    /// to.",
6210    ///            "type": "string"
6211    ///          },
6212    ///          "jobid": {
6213    ///            "type": "integer"
6214    ///          },
6215    ///          "name": {
6216    ///            "type": "string"
6217    ///          },
6218    ///          "size": {
6219    ///            "type": "integer"
6220    ///          },
6221    ///          "srcFs": {
6222    ///            "description": "Source remote or filesystem used for the
6223    /// transfer.",
6224    ///            "type": "string"
6225    ///          },
6226    ///          "srcRemote": {
6227    ///            "description": "Source path within `srcFs`, when provided.",
6228    ///            "type": "string"
6229    ///          },
6230    ///          "started_at": {
6231    ///            "description": "ISO8601 timestamp when the transfer
6232    /// started.",
6233    ///            "type": "string"
6234    ///          },
6235    ///          "timestamp": {
6236    ///            "type": "integer"
6237    ///          },
6238    ///          "what": {
6239    ///            "type": "string",
6240    ///            "enum": [
6241    ///              "transferring",
6242    ///              "deleting",
6243    ///              "checking",
6244    ///              "importing",
6245    ///              "hashing",
6246    ///              "merging",
6247    ///              "listing",
6248    ///              "moving",
6249    ///              "renaming"
6250    ///            ]
6251    ///          }
6252    ///        },
6253    ///        "additionalProperties": true
6254    ///      }
6255    ///    }
6256    ///  }
6257    ///}
6258    /// ```
6259    /// </details>
6260    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6261    pub struct CoreTransferredResponse {
6262        pub transferred: ::std::vec::Vec<CoreTransferredResponseTransferredItem>,
6263    }
6264
6265    impl ::std::convert::From<&CoreTransferredResponse> for CoreTransferredResponse {
6266        fn from(value: &CoreTransferredResponse) -> Self {
6267            value.clone()
6268        }
6269    }
6270
6271    ///`CoreTransferredResponseTransferredItem`
6272    ///
6273    /// <details><summary>JSON schema</summary>
6274    ///
6275    /// ```json
6276    ///{
6277    ///  "type": "object",
6278    ///  "required": [
6279    ///    "bytes",
6280    ///    "checked",
6281    ///    "completed_at",
6282    ///    "error",
6283    ///    "group",
6284    ///    "name",
6285    ///    "size",
6286    ///    "started_at",
6287    ///    "what"
6288    ///  ],
6289    ///  "properties": {
6290    ///    "bytes": {
6291    ///      "type": "integer"
6292    ///    },
6293    ///    "checked": {
6294    ///      "type": "boolean"
6295    ///    },
6296    ///    "completed_at": {
6297    ///      "description": "ISO8601 timestamp when the transfer completed.",
6298    ///      "type": "string"
6299    ///    },
6300    ///    "dstFs": {
6301    ///      "description": "Destination remote or filesystem used for the
6302    /// transfer.",
6303    ///      "type": "string"
6304    ///    },
6305    ///    "dstRemote": {
6306    ///      "description": "Destination path within `dstFs`, when provided.",
6307    ///      "type": "string"
6308    ///    },
6309    ///    "error": {
6310    ///      "type": "string"
6311    ///    },
6312    ///    "group": {
6313    ///      "description": "Stats group identifier this transfer belonged to.",
6314    ///      "type": "string"
6315    ///    },
6316    ///    "jobid": {
6317    ///      "type": "integer"
6318    ///    },
6319    ///    "name": {
6320    ///      "type": "string"
6321    ///    },
6322    ///    "size": {
6323    ///      "type": "integer"
6324    ///    },
6325    ///    "srcFs": {
6326    ///      "description": "Source remote or filesystem used for the
6327    /// transfer.",
6328    ///      "type": "string"
6329    ///    },
6330    ///    "srcRemote": {
6331    ///      "description": "Source path within `srcFs`, when provided.",
6332    ///      "type": "string"
6333    ///    },
6334    ///    "started_at": {
6335    ///      "description": "ISO8601 timestamp when the transfer started.",
6336    ///      "type": "string"
6337    ///    },
6338    ///    "timestamp": {
6339    ///      "type": "integer"
6340    ///    },
6341    ///    "what": {
6342    ///      "type": "string",
6343    ///      "enum": [
6344    ///        "transferring",
6345    ///        "deleting",
6346    ///        "checking",
6347    ///        "importing",
6348    ///        "hashing",
6349    ///        "merging",
6350    ///        "listing",
6351    ///        "moving",
6352    ///        "renaming"
6353    ///      ]
6354    ///    }
6355    ///  },
6356    ///  "additionalProperties": true
6357    ///}
6358    /// ```
6359    /// </details>
6360    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6361    pub struct CoreTransferredResponseTransferredItem {
6362        pub bytes: i64,
6363        pub checked: bool,
6364        ///ISO8601 timestamp when the transfer completed.
6365        pub completed_at: ::std::string::String,
6366        ///Destination remote or filesystem used for the transfer.
6367        #[serde(
6368            rename = "dstFs",
6369            default,
6370            skip_serializing_if = "::std::option::Option::is_none"
6371        )]
6372        pub dst_fs: ::std::option::Option<::std::string::String>,
6373        ///Destination path within `dstFs`, when provided.
6374        #[serde(
6375            rename = "dstRemote",
6376            default,
6377            skip_serializing_if = "::std::option::Option::is_none"
6378        )]
6379        pub dst_remote: ::std::option::Option<::std::string::String>,
6380        pub error: ::std::string::String,
6381        ///Stats group identifier this transfer belonged to.
6382        pub group: ::std::string::String,
6383        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6384        pub jobid: ::std::option::Option<i64>,
6385        pub name: ::std::string::String,
6386        pub size: i64,
6387        ///Source remote or filesystem used for the transfer.
6388        #[serde(
6389            rename = "srcFs",
6390            default,
6391            skip_serializing_if = "::std::option::Option::is_none"
6392        )]
6393        pub src_fs: ::std::option::Option<::std::string::String>,
6394        ///Source path within `srcFs`, when provided.
6395        #[serde(
6396            rename = "srcRemote",
6397            default,
6398            skip_serializing_if = "::std::option::Option::is_none"
6399        )]
6400        pub src_remote: ::std::option::Option<::std::string::String>,
6401        ///ISO8601 timestamp when the transfer started.
6402        pub started_at: ::std::string::String,
6403        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6404        pub timestamp: ::std::option::Option<i64>,
6405        pub what: CoreTransferredResponseTransferredItemWhat,
6406    }
6407
6408    impl ::std::convert::From<&CoreTransferredResponseTransferredItem>
6409        for CoreTransferredResponseTransferredItem
6410    {
6411        fn from(value: &CoreTransferredResponseTransferredItem) -> Self {
6412            value.clone()
6413        }
6414    }
6415
6416    ///`CoreTransferredResponseTransferredItemWhat`
6417    ///
6418    /// <details><summary>JSON schema</summary>
6419    ///
6420    /// ```json
6421    ///{
6422    ///  "type": "string",
6423    ///  "enum": [
6424    ///    "transferring",
6425    ///    "deleting",
6426    ///    "checking",
6427    ///    "importing",
6428    ///    "hashing",
6429    ///    "merging",
6430    ///    "listing",
6431    ///    "moving",
6432    ///    "renaming"
6433    ///  ]
6434    ///}
6435    /// ```
6436    /// </details>
6437    #[derive(
6438        :: serde :: Deserialize,
6439        :: serde :: Serialize,
6440        Clone,
6441        Copy,
6442        Debug,
6443        Eq,
6444        Hash,
6445        Ord,
6446        PartialEq,
6447        PartialOrd,
6448    )]
6449    pub enum CoreTransferredResponseTransferredItemWhat {
6450        #[serde(rename = "transferring")]
6451        Transferring,
6452        #[serde(rename = "deleting")]
6453        Deleting,
6454        #[serde(rename = "checking")]
6455        Checking,
6456        #[serde(rename = "importing")]
6457        Importing,
6458        #[serde(rename = "hashing")]
6459        Hashing,
6460        #[serde(rename = "merging")]
6461        Merging,
6462        #[serde(rename = "listing")]
6463        Listing,
6464        #[serde(rename = "moving")]
6465        Moving,
6466        #[serde(rename = "renaming")]
6467        Renaming,
6468    }
6469
6470    impl ::std::convert::From<&Self> for CoreTransferredResponseTransferredItemWhat {
6471        fn from(value: &CoreTransferredResponseTransferredItemWhat) -> Self {
6472            value.clone()
6473        }
6474    }
6475
6476    impl ::std::fmt::Display for CoreTransferredResponseTransferredItemWhat {
6477        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6478            match *self {
6479                Self::Transferring => f.write_str("transferring"),
6480                Self::Deleting => f.write_str("deleting"),
6481                Self::Checking => f.write_str("checking"),
6482                Self::Importing => f.write_str("importing"),
6483                Self::Hashing => f.write_str("hashing"),
6484                Self::Merging => f.write_str("merging"),
6485                Self::Listing => f.write_str("listing"),
6486                Self::Moving => f.write_str("moving"),
6487                Self::Renaming => f.write_str("renaming"),
6488            }
6489        }
6490    }
6491
6492    impl ::std::str::FromStr for CoreTransferredResponseTransferredItemWhat {
6493        type Err = self::error::ConversionError;
6494        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6495            match value {
6496                "transferring" => Ok(Self::Transferring),
6497                "deleting" => Ok(Self::Deleting),
6498                "checking" => Ok(Self::Checking),
6499                "importing" => Ok(Self::Importing),
6500                "hashing" => Ok(Self::Hashing),
6501                "merging" => Ok(Self::Merging),
6502                "listing" => Ok(Self::Listing),
6503                "moving" => Ok(Self::Moving),
6504                "renaming" => Ok(Self::Renaming),
6505                _ => Err("invalid value".into()),
6506            }
6507        }
6508    }
6509
6510    impl ::std::convert::TryFrom<&str> for CoreTransferredResponseTransferredItemWhat {
6511        type Error = self::error::ConversionError;
6512        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6513            value.parse()
6514        }
6515    }
6516
6517    impl ::std::convert::TryFrom<&::std::string::String>
6518        for CoreTransferredResponseTransferredItemWhat
6519    {
6520        type Error = self::error::ConversionError;
6521        fn try_from(
6522            value: &::std::string::String,
6523        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6524            value.parse()
6525        }
6526    }
6527
6528    impl ::std::convert::TryFrom<::std::string::String> for CoreTransferredResponseTransferredItemWhat {
6529        type Error = self::error::ConversionError;
6530        fn try_from(
6531            value: ::std::string::String,
6532        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6533            value.parse()
6534        }
6535    }
6536
6537    ///`CoreVersionPrefer`
6538    ///
6539    /// <details><summary>JSON schema</summary>
6540    ///
6541    /// ```json
6542    ///{
6543    ///  "type": "string",
6544    ///  "enum": [
6545    ///    "respond-async"
6546    ///  ]
6547    ///}
6548    /// ```
6549    /// </details>
6550    #[derive(
6551        :: serde :: Deserialize,
6552        :: serde :: Serialize,
6553        Clone,
6554        Copy,
6555        Debug,
6556        Eq,
6557        Hash,
6558        Ord,
6559        PartialEq,
6560        PartialOrd,
6561    )]
6562    pub enum CoreVersionPrefer {
6563        #[serde(rename = "respond-async")]
6564        RespondAsync,
6565    }
6566
6567    impl ::std::convert::From<&Self> for CoreVersionPrefer {
6568        fn from(value: &CoreVersionPrefer) -> Self {
6569            value.clone()
6570        }
6571    }
6572
6573    impl ::std::fmt::Display for CoreVersionPrefer {
6574        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6575            match *self {
6576                Self::RespondAsync => f.write_str("respond-async"),
6577            }
6578        }
6579    }
6580
6581    impl ::std::str::FromStr for CoreVersionPrefer {
6582        type Err = self::error::ConversionError;
6583        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6584            match value {
6585                "respond-async" => Ok(Self::RespondAsync),
6586                _ => Err("invalid value".into()),
6587            }
6588        }
6589    }
6590
6591    impl ::std::convert::TryFrom<&str> for CoreVersionPrefer {
6592        type Error = self::error::ConversionError;
6593        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6594            value.parse()
6595        }
6596    }
6597
6598    impl ::std::convert::TryFrom<&::std::string::String> for CoreVersionPrefer {
6599        type Error = self::error::ConversionError;
6600        fn try_from(
6601            value: &::std::string::String,
6602        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6603            value.parse()
6604        }
6605    }
6606
6607    impl ::std::convert::TryFrom<::std::string::String> for CoreVersionPrefer {
6608        type Error = self::error::ConversionError;
6609        fn try_from(
6610            value: ::std::string::String,
6611        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6612            value.parse()
6613        }
6614    }
6615
6616    ///`CoreVersionRequest`
6617    ///
6618    /// <details><summary>JSON schema</summary>
6619    ///
6620    /// ```json
6621    ///{
6622    ///  "type": "object",
6623    ///  "properties": {
6624    ///    "_async": {
6625    ///      "description": "Run the command asynchronously. Returns a job id
6626    /// immediately.",
6627    ///      "type": "boolean"
6628    ///    },
6629    ///    "_group": {
6630    ///      "description": "Assign the request to a custom stats group.",
6631    ///      "type": "string"
6632    ///    }
6633    ///  }
6634    ///}
6635    /// ```
6636    /// </details>
6637    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6638    pub struct CoreVersionRequest {
6639        ///Run the command asynchronously. Returns a job id immediately.
6640        #[serde(
6641            rename = "_async",
6642            default,
6643            skip_serializing_if = "::std::option::Option::is_none"
6644        )]
6645        pub async_: ::std::option::Option<bool>,
6646        ///Assign the request to a custom stats group.
6647        #[serde(
6648            rename = "_group",
6649            default,
6650            skip_serializing_if = "::std::option::Option::is_none"
6651        )]
6652        pub group: ::std::option::Option<::std::string::String>,
6653    }
6654
6655    impl ::std::convert::From<&CoreVersionRequest> for CoreVersionRequest {
6656        fn from(value: &CoreVersionRequest) -> Self {
6657            value.clone()
6658        }
6659    }
6660
6661    impl ::std::default::Default for CoreVersionRequest {
6662        fn default() -> Self {
6663            Self {
6664                async_: Default::default(),
6665                group: Default::default(),
6666            }
6667        }
6668    }
6669
6670    ///`CoreVersionResponse`
6671    ///
6672    /// <details><summary>JSON schema</summary>
6673    ///
6674    /// ```json
6675    ///{
6676    ///  "type": "object",
6677    ///  "required": [
6678    ///    "arch",
6679    ///    "decomposed",
6680    ///    "goTags",
6681    ///    "goVersion",
6682    ///    "isBeta",
6683    ///    "isGit",
6684    ///    "linking",
6685    ///    "os",
6686    ///    "version"
6687    ///  ],
6688    ///  "properties": {
6689    ///    "arch": {
6690    ///      "description": "CPU architecture (e.g. amd64, arm64).",
6691    ///      "type": "string"
6692    ///    },
6693    ///    "decomposed": {
6694    ///      "description": "Version number broken into components.",
6695    ///      "type": "array",
6696    ///      "items": {
6697    ///        "type": "number"
6698    ///      }
6699    ///    },
6700    ///    "goTags": {
6701    ///      "description": "Space separated Go build tags, if any.",
6702    ///      "type": "string"
6703    ///    },
6704    ///    "goVersion": {
6705    ///      "description": "Go toolchain version used to build rclone.",
6706    ///      "type": "string"
6707    ///    },
6708    ///    "isBeta": {
6709    ///      "description": "Indicates whether this build is a beta version.",
6710    ///      "type": "boolean"
6711    ///    },
6712    ///    "isGit": {
6713    ///      "description": "True when built directly from a git checkout.",
6714    ///      "type": "boolean"
6715    ///    },
6716    ///    "linking": {
6717    ///      "description": "Linking mode for the binary (static or dynamic).",
6718    ///      "type": "string"
6719    ///    },
6720    ///    "os": {
6721    ///      "description": "Operating system rclone is running on (e.g. linux,
6722    /// darwin).",
6723    ///      "type": "string"
6724    ///    },
6725    ///    "osArch": {
6726    ///      "description": "CPU architecture in use (e.g. arm64 (ARMv8
6727    /// compatible)).",
6728    ///      "type": "string"
6729    ///    },
6730    ///    "osKernel": {
6731    ///      "description": "OS Kernel version (e.g. 6.8.0-86-generic
6732    /// (x86_64)).",
6733    ///      "type": "string"
6734    ///    },
6735    ///    "osVersion": {
6736    ///      "description": "OS Version (e.g. ubuntu 24.04 (64 bit)).",
6737    ///      "type": "string"
6738    ///    },
6739    ///    "version": {
6740    ///      "description": "Full semantic version string (e.g. 1.67.0).",
6741    ///      "type": "string"
6742    ///    }
6743    ///  }
6744    ///}
6745    /// ```
6746    /// </details>
6747    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6748    pub struct CoreVersionResponse {
6749        ///CPU architecture (e.g. amd64, arm64).
6750        pub arch: ::std::string::String,
6751        ///Version number broken into components.
6752        pub decomposed: ::std::vec::Vec<f64>,
6753        ///Space separated Go build tags, if any.
6754        #[serde(rename = "goTags")]
6755        pub go_tags: ::std::string::String,
6756        ///Go toolchain version used to build rclone.
6757        #[serde(rename = "goVersion")]
6758        pub go_version: ::std::string::String,
6759        ///Indicates whether this build is a beta version.
6760        #[serde(rename = "isBeta")]
6761        pub is_beta: bool,
6762        ///True when built directly from a git checkout.
6763        #[serde(rename = "isGit")]
6764        pub is_git: bool,
6765        ///Linking mode for the binary (static or dynamic).
6766        pub linking: ::std::string::String,
6767        ///Operating system rclone is running on (e.g. linux, darwin).
6768        pub os: ::std::string::String,
6769        ///CPU architecture in use (e.g. arm64 (ARMv8 compatible)).
6770        #[serde(
6771            rename = "osArch",
6772            default,
6773            skip_serializing_if = "::std::option::Option::is_none"
6774        )]
6775        pub os_arch: ::std::option::Option<::std::string::String>,
6776        ///OS Kernel version (e.g. 6.8.0-86-generic (x86_64)).
6777        #[serde(
6778            rename = "osKernel",
6779            default,
6780            skip_serializing_if = "::std::option::Option::is_none"
6781        )]
6782        pub os_kernel: ::std::option::Option<::std::string::String>,
6783        ///OS Version (e.g. ubuntu 24.04 (64 bit)).
6784        #[serde(
6785            rename = "osVersion",
6786            default,
6787            skip_serializing_if = "::std::option::Option::is_none"
6788        )]
6789        pub os_version: ::std::option::Option<::std::string::String>,
6790        ///Full semantic version string (e.g. 1.67.0).
6791        pub version: ::std::string::String,
6792    }
6793
6794    impl ::std::convert::From<&CoreVersionResponse> for CoreVersionResponse {
6795        fn from(value: &CoreVersionResponse) -> Self {
6796            value.clone()
6797        }
6798    }
6799
6800    ///`DebugSetBlockProfileRatePrefer`
6801    ///
6802    /// <details><summary>JSON schema</summary>
6803    ///
6804    /// ```json
6805    ///{
6806    ///  "type": "string",
6807    ///  "enum": [
6808    ///    "respond-async"
6809    ///  ]
6810    ///}
6811    /// ```
6812    /// </details>
6813    #[derive(
6814        :: serde :: Deserialize,
6815        :: serde :: Serialize,
6816        Clone,
6817        Copy,
6818        Debug,
6819        Eq,
6820        Hash,
6821        Ord,
6822        PartialEq,
6823        PartialOrd,
6824    )]
6825    pub enum DebugSetBlockProfileRatePrefer {
6826        #[serde(rename = "respond-async")]
6827        RespondAsync,
6828    }
6829
6830    impl ::std::convert::From<&Self> for DebugSetBlockProfileRatePrefer {
6831        fn from(value: &DebugSetBlockProfileRatePrefer) -> Self {
6832            value.clone()
6833        }
6834    }
6835
6836    impl ::std::fmt::Display for DebugSetBlockProfileRatePrefer {
6837        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6838            match *self {
6839                Self::RespondAsync => f.write_str("respond-async"),
6840            }
6841        }
6842    }
6843
6844    impl ::std::str::FromStr for DebugSetBlockProfileRatePrefer {
6845        type Err = self::error::ConversionError;
6846        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6847            match value {
6848                "respond-async" => Ok(Self::RespondAsync),
6849                _ => Err("invalid value".into()),
6850            }
6851        }
6852    }
6853
6854    impl ::std::convert::TryFrom<&str> for DebugSetBlockProfileRatePrefer {
6855        type Error = self::error::ConversionError;
6856        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6857            value.parse()
6858        }
6859    }
6860
6861    impl ::std::convert::TryFrom<&::std::string::String> for DebugSetBlockProfileRatePrefer {
6862        type Error = self::error::ConversionError;
6863        fn try_from(
6864            value: &::std::string::String,
6865        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6866            value.parse()
6867        }
6868    }
6869
6870    impl ::std::convert::TryFrom<::std::string::String> for DebugSetBlockProfileRatePrefer {
6871        type Error = self::error::ConversionError;
6872        fn try_from(
6873            value: ::std::string::String,
6874        ) -> ::std::result::Result<Self, self::error::ConversionError> {
6875            value.parse()
6876        }
6877    }
6878
6879    ///`DebugSetBlockProfileRateRequest`
6880    ///
6881    /// <details><summary>JSON schema</summary>
6882    ///
6883    /// ```json
6884    ///{
6885    ///  "type": "object",
6886    ///  "properties": {
6887    ///    "_async": {
6888    ///      "description": "Run the command asynchronously. Returns a job id
6889    /// immediately.",
6890    ///      "type": "boolean"
6891    ///    },
6892    ///    "_group": {
6893    ///      "description": "Assign the request to a custom stats group.",
6894    ///      "type": "string"
6895    ///    },
6896    ///    "rate": {
6897    ///      "description": "Sampling interval in nanoseconds for blocking
6898    /// profile collection; use 1 to capture all events.",
6899    ///      "type": "integer"
6900    ///    }
6901    ///  }
6902    ///}
6903    /// ```
6904    /// </details>
6905    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6906    pub struct DebugSetBlockProfileRateRequest {
6907        ///Run the command asynchronously. Returns a job id immediately.
6908        #[serde(
6909            rename = "_async",
6910            default,
6911            skip_serializing_if = "::std::option::Option::is_none"
6912        )]
6913        pub async_: ::std::option::Option<bool>,
6914        ///Assign the request to a custom stats group.
6915        #[serde(
6916            rename = "_group",
6917            default,
6918            skip_serializing_if = "::std::option::Option::is_none"
6919        )]
6920        pub group: ::std::option::Option<::std::string::String>,
6921        ///Sampling interval in nanoseconds for blocking profile collection;
6922        /// use 1 to capture all events.
6923        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6924        pub rate: ::std::option::Option<i64>,
6925    }
6926
6927    impl ::std::convert::From<&DebugSetBlockProfileRateRequest> for DebugSetBlockProfileRateRequest {
6928        fn from(value: &DebugSetBlockProfileRateRequest) -> Self {
6929            value.clone()
6930        }
6931    }
6932
6933    impl ::std::default::Default for DebugSetBlockProfileRateRequest {
6934        fn default() -> Self {
6935            Self {
6936                async_: Default::default(),
6937                group: Default::default(),
6938                rate: Default::default(),
6939            }
6940        }
6941    }
6942
6943    ///`DebugSetGcPercentPrefer`
6944    ///
6945    /// <details><summary>JSON schema</summary>
6946    ///
6947    /// ```json
6948    ///{
6949    ///  "type": "string",
6950    ///  "enum": [
6951    ///    "respond-async"
6952    ///  ]
6953    ///}
6954    /// ```
6955    /// </details>
6956    #[derive(
6957        :: serde :: Deserialize,
6958        :: serde :: Serialize,
6959        Clone,
6960        Copy,
6961        Debug,
6962        Eq,
6963        Hash,
6964        Ord,
6965        PartialEq,
6966        PartialOrd,
6967    )]
6968    pub enum DebugSetGcPercentPrefer {
6969        #[serde(rename = "respond-async")]
6970        RespondAsync,
6971    }
6972
6973    impl ::std::convert::From<&Self> for DebugSetGcPercentPrefer {
6974        fn from(value: &DebugSetGcPercentPrefer) -> Self {
6975            value.clone()
6976        }
6977    }
6978
6979    impl ::std::fmt::Display for DebugSetGcPercentPrefer {
6980        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6981            match *self {
6982                Self::RespondAsync => f.write_str("respond-async"),
6983            }
6984        }
6985    }
6986
6987    impl ::std::str::FromStr for DebugSetGcPercentPrefer {
6988        type Err = self::error::ConversionError;
6989        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
6990            match value {
6991                "respond-async" => Ok(Self::RespondAsync),
6992                _ => Err("invalid value".into()),
6993            }
6994        }
6995    }
6996
6997    impl ::std::convert::TryFrom<&str> for DebugSetGcPercentPrefer {
6998        type Error = self::error::ConversionError;
6999        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7000            value.parse()
7001        }
7002    }
7003
7004    impl ::std::convert::TryFrom<&::std::string::String> for DebugSetGcPercentPrefer {
7005        type Error = self::error::ConversionError;
7006        fn try_from(
7007            value: &::std::string::String,
7008        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7009            value.parse()
7010        }
7011    }
7012
7013    impl ::std::convert::TryFrom<::std::string::String> for DebugSetGcPercentPrefer {
7014        type Error = self::error::ConversionError;
7015        fn try_from(
7016            value: ::std::string::String,
7017        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7018            value.parse()
7019        }
7020    }
7021
7022    ///`DebugSetGcPercentRequest`
7023    ///
7024    /// <details><summary>JSON schema</summary>
7025    ///
7026    /// ```json
7027    ///{
7028    ///  "type": "object",
7029    ///  "properties": {
7030    ///    "_async": {
7031    ///      "description": "Run the command asynchronously. Returns a job id
7032    /// immediately.",
7033    ///      "type": "boolean"
7034    ///    },
7035    ///    "_group": {
7036    ///      "description": "Assign the request to a custom stats group.",
7037    ///      "type": "string"
7038    ///    },
7039    ///    "gc-percent": {
7040    ///      "description": "Target percentage of newly allocated data to
7041    /// trigger garbage collection.",
7042    ///      "type": "integer"
7043    ///    }
7044    ///  }
7045    ///}
7046    /// ```
7047    /// </details>
7048    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7049    pub struct DebugSetGcPercentRequest {
7050        ///Run the command asynchronously. Returns a job id immediately.
7051        #[serde(
7052            rename = "_async",
7053            default,
7054            skip_serializing_if = "::std::option::Option::is_none"
7055        )]
7056        pub async_: ::std::option::Option<bool>,
7057        ///Target percentage of newly allocated data to trigger garbage
7058        /// collection.
7059        #[serde(
7060            rename = "gc-percent",
7061            default,
7062            skip_serializing_if = "::std::option::Option::is_none"
7063        )]
7064        pub gc_percent: ::std::option::Option<i64>,
7065        ///Assign the request to a custom stats group.
7066        #[serde(
7067            rename = "_group",
7068            default,
7069            skip_serializing_if = "::std::option::Option::is_none"
7070        )]
7071        pub group: ::std::option::Option<::std::string::String>,
7072    }
7073
7074    impl ::std::convert::From<&DebugSetGcPercentRequest> for DebugSetGcPercentRequest {
7075        fn from(value: &DebugSetGcPercentRequest) -> Self {
7076            value.clone()
7077        }
7078    }
7079
7080    impl ::std::default::Default for DebugSetGcPercentRequest {
7081        fn default() -> Self {
7082            Self {
7083                async_: Default::default(),
7084                gc_percent: Default::default(),
7085                group: Default::default(),
7086            }
7087        }
7088    }
7089
7090    ///`DebugSetGcPercentResponse`
7091    ///
7092    /// <details><summary>JSON schema</summary>
7093    ///
7094    /// ```json
7095    ///{
7096    ///  "type": "object",
7097    ///  "required": [
7098    ///    "existing-gc-percent"
7099    ///  ],
7100    ///  "properties": {
7101    ///    "existing-gc-percent": {
7102    ///      "type": "integer"
7103    ///    }
7104    ///  }
7105    ///}
7106    /// ```
7107    /// </details>
7108    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7109    pub struct DebugSetGcPercentResponse {
7110        #[serde(rename = "existing-gc-percent")]
7111        pub existing_gc_percent: i64,
7112    }
7113
7114    impl ::std::convert::From<&DebugSetGcPercentResponse> for DebugSetGcPercentResponse {
7115        fn from(value: &DebugSetGcPercentResponse) -> Self {
7116            value.clone()
7117        }
7118    }
7119
7120    ///`DebugSetMutexProfileFractionPrefer`
7121    ///
7122    /// <details><summary>JSON schema</summary>
7123    ///
7124    /// ```json
7125    ///{
7126    ///  "type": "string",
7127    ///  "enum": [
7128    ///    "respond-async"
7129    ///  ]
7130    ///}
7131    /// ```
7132    /// </details>
7133    #[derive(
7134        :: serde :: Deserialize,
7135        :: serde :: Serialize,
7136        Clone,
7137        Copy,
7138        Debug,
7139        Eq,
7140        Hash,
7141        Ord,
7142        PartialEq,
7143        PartialOrd,
7144    )]
7145    pub enum DebugSetMutexProfileFractionPrefer {
7146        #[serde(rename = "respond-async")]
7147        RespondAsync,
7148    }
7149
7150    impl ::std::convert::From<&Self> for DebugSetMutexProfileFractionPrefer {
7151        fn from(value: &DebugSetMutexProfileFractionPrefer) -> Self {
7152            value.clone()
7153        }
7154    }
7155
7156    impl ::std::fmt::Display for DebugSetMutexProfileFractionPrefer {
7157        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7158            match *self {
7159                Self::RespondAsync => f.write_str("respond-async"),
7160            }
7161        }
7162    }
7163
7164    impl ::std::str::FromStr for DebugSetMutexProfileFractionPrefer {
7165        type Err = self::error::ConversionError;
7166        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7167            match value {
7168                "respond-async" => Ok(Self::RespondAsync),
7169                _ => Err("invalid value".into()),
7170            }
7171        }
7172    }
7173
7174    impl ::std::convert::TryFrom<&str> for DebugSetMutexProfileFractionPrefer {
7175        type Error = self::error::ConversionError;
7176        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7177            value.parse()
7178        }
7179    }
7180
7181    impl ::std::convert::TryFrom<&::std::string::String> for DebugSetMutexProfileFractionPrefer {
7182        type Error = self::error::ConversionError;
7183        fn try_from(
7184            value: &::std::string::String,
7185        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7186            value.parse()
7187        }
7188    }
7189
7190    impl ::std::convert::TryFrom<::std::string::String> for DebugSetMutexProfileFractionPrefer {
7191        type Error = self::error::ConversionError;
7192        fn try_from(
7193            value: ::std::string::String,
7194        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7195            value.parse()
7196        }
7197    }
7198
7199    ///`DebugSetMutexProfileFractionRequest`
7200    ///
7201    /// <details><summary>JSON schema</summary>
7202    ///
7203    /// ```json
7204    ///{
7205    ///  "type": "object",
7206    ///  "properties": {
7207    ///    "_async": {
7208    ///      "description": "Run the command asynchronously. Returns a job id
7209    /// immediately.",
7210    ///      "type": "boolean"
7211    ///    },
7212    ///    "_group": {
7213    ///      "description": "Assign the request to a custom stats group.",
7214    ///      "type": "string"
7215    ///    },
7216    ///    "rate": {
7217    ///      "description": "Sampling fraction for mutex contention profiling;
7218    /// set to 0 to disable.",
7219    ///      "type": "integer"
7220    ///    }
7221    ///  }
7222    ///}
7223    /// ```
7224    /// </details>
7225    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7226    pub struct DebugSetMutexProfileFractionRequest {
7227        ///Run the command asynchronously. Returns a job id immediately.
7228        #[serde(
7229            rename = "_async",
7230            default,
7231            skip_serializing_if = "::std::option::Option::is_none"
7232        )]
7233        pub async_: ::std::option::Option<bool>,
7234        ///Assign the request to a custom stats group.
7235        #[serde(
7236            rename = "_group",
7237            default,
7238            skip_serializing_if = "::std::option::Option::is_none"
7239        )]
7240        pub group: ::std::option::Option<::std::string::String>,
7241        ///Sampling fraction for mutex contention profiling; set to 0 to
7242        /// disable.
7243        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7244        pub rate: ::std::option::Option<i64>,
7245    }
7246
7247    impl ::std::convert::From<&DebugSetMutexProfileFractionRequest>
7248        for DebugSetMutexProfileFractionRequest
7249    {
7250        fn from(value: &DebugSetMutexProfileFractionRequest) -> Self {
7251            value.clone()
7252        }
7253    }
7254
7255    impl ::std::default::Default for DebugSetMutexProfileFractionRequest {
7256        fn default() -> Self {
7257            Self {
7258                async_: Default::default(),
7259                group: Default::default(),
7260                rate: Default::default(),
7261            }
7262        }
7263    }
7264
7265    ///`DebugSetMutexProfileFractionResponse`
7266    ///
7267    /// <details><summary>JSON schema</summary>
7268    ///
7269    /// ```json
7270    ///{
7271    ///  "type": "object",
7272    ///  "required": [
7273    ///    "previousRate"
7274    ///  ],
7275    ///  "properties": {
7276    ///    "previousRate": {
7277    ///      "type": "integer"
7278    ///    }
7279    ///  }
7280    ///}
7281    /// ```
7282    /// </details>
7283    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7284    pub struct DebugSetMutexProfileFractionResponse {
7285        #[serde(rename = "previousRate")]
7286        pub previous_rate: i64,
7287    }
7288
7289    impl ::std::convert::From<&DebugSetMutexProfileFractionResponse>
7290        for DebugSetMutexProfileFractionResponse
7291    {
7292        fn from(value: &DebugSetMutexProfileFractionResponse) -> Self {
7293            value.clone()
7294        }
7295    }
7296
7297    ///`DebugSetSoftMemoryLimitPrefer`
7298    ///
7299    /// <details><summary>JSON schema</summary>
7300    ///
7301    /// ```json
7302    ///{
7303    ///  "type": "string",
7304    ///  "enum": [
7305    ///    "respond-async"
7306    ///  ]
7307    ///}
7308    /// ```
7309    /// </details>
7310    #[derive(
7311        :: serde :: Deserialize,
7312        :: serde :: Serialize,
7313        Clone,
7314        Copy,
7315        Debug,
7316        Eq,
7317        Hash,
7318        Ord,
7319        PartialEq,
7320        PartialOrd,
7321    )]
7322    pub enum DebugSetSoftMemoryLimitPrefer {
7323        #[serde(rename = "respond-async")]
7324        RespondAsync,
7325    }
7326
7327    impl ::std::convert::From<&Self> for DebugSetSoftMemoryLimitPrefer {
7328        fn from(value: &DebugSetSoftMemoryLimitPrefer) -> Self {
7329            value.clone()
7330        }
7331    }
7332
7333    impl ::std::fmt::Display for DebugSetSoftMemoryLimitPrefer {
7334        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7335            match *self {
7336                Self::RespondAsync => f.write_str("respond-async"),
7337            }
7338        }
7339    }
7340
7341    impl ::std::str::FromStr for DebugSetSoftMemoryLimitPrefer {
7342        type Err = self::error::ConversionError;
7343        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7344            match value {
7345                "respond-async" => Ok(Self::RespondAsync),
7346                _ => Err("invalid value".into()),
7347            }
7348        }
7349    }
7350
7351    impl ::std::convert::TryFrom<&str> for DebugSetSoftMemoryLimitPrefer {
7352        type Error = self::error::ConversionError;
7353        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7354            value.parse()
7355        }
7356    }
7357
7358    impl ::std::convert::TryFrom<&::std::string::String> for DebugSetSoftMemoryLimitPrefer {
7359        type Error = self::error::ConversionError;
7360        fn try_from(
7361            value: &::std::string::String,
7362        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7363            value.parse()
7364        }
7365    }
7366
7367    impl ::std::convert::TryFrom<::std::string::String> for DebugSetSoftMemoryLimitPrefer {
7368        type Error = self::error::ConversionError;
7369        fn try_from(
7370            value: ::std::string::String,
7371        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7372            value.parse()
7373        }
7374    }
7375
7376    ///`DebugSetSoftMemoryLimitRequest`
7377    ///
7378    /// <details><summary>JSON schema</summary>
7379    ///
7380    /// ```json
7381    ///{
7382    ///  "type": "object",
7383    ///  "properties": {
7384    ///    "_async": {
7385    ///      "description": "Run the command asynchronously. Returns a job id
7386    /// immediately.",
7387    ///      "type": "boolean"
7388    ///    },
7389    ///    "_group": {
7390    ///      "description": "Assign the request to a custom stats group.",
7391    ///      "type": "string"
7392    ///    },
7393    ///    "mem-limit": {
7394    ///      "description": "Soft memory limit for the Go runtime in bytes.",
7395    ///      "type": "integer"
7396    ///    }
7397    ///  }
7398    ///}
7399    /// ```
7400    /// </details>
7401    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7402    pub struct DebugSetSoftMemoryLimitRequest {
7403        ///Run the command asynchronously. Returns a job id immediately.
7404        #[serde(
7405            rename = "_async",
7406            default,
7407            skip_serializing_if = "::std::option::Option::is_none"
7408        )]
7409        pub async_: ::std::option::Option<bool>,
7410        ///Assign the request to a custom stats group.
7411        #[serde(
7412            rename = "_group",
7413            default,
7414            skip_serializing_if = "::std::option::Option::is_none"
7415        )]
7416        pub group: ::std::option::Option<::std::string::String>,
7417        ///Soft memory limit for the Go runtime in bytes.
7418        #[serde(
7419            rename = "mem-limit",
7420            default,
7421            skip_serializing_if = "::std::option::Option::is_none"
7422        )]
7423        pub mem_limit: ::std::option::Option<i64>,
7424    }
7425
7426    impl ::std::convert::From<&DebugSetSoftMemoryLimitRequest> for DebugSetSoftMemoryLimitRequest {
7427        fn from(value: &DebugSetSoftMemoryLimitRequest) -> Self {
7428            value.clone()
7429        }
7430    }
7431
7432    impl ::std::default::Default for DebugSetSoftMemoryLimitRequest {
7433        fn default() -> Self {
7434            Self {
7435                async_: Default::default(),
7436                group: Default::default(),
7437                mem_limit: Default::default(),
7438            }
7439        }
7440    }
7441
7442    ///`DebugSetSoftMemoryLimitResponse`
7443    ///
7444    /// <details><summary>JSON schema</summary>
7445    ///
7446    /// ```json
7447    ///{
7448    ///  "type": "object",
7449    ///  "required": [
7450    ///    "existing-mem-limit"
7451    ///  ],
7452    ///  "properties": {
7453    ///    "existing-mem-limit": {
7454    ///      "type": "integer"
7455    ///    }
7456    ///  }
7457    ///}
7458    /// ```
7459    /// </details>
7460    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7461    pub struct DebugSetSoftMemoryLimitResponse {
7462        #[serde(rename = "existing-mem-limit")]
7463        pub existing_mem_limit: i64,
7464    }
7465
7466    impl ::std::convert::From<&DebugSetSoftMemoryLimitResponse> for DebugSetSoftMemoryLimitResponse {
7467        fn from(value: &DebugSetSoftMemoryLimitResponse) -> Self {
7468            value.clone()
7469        }
7470    }
7471
7472    ///`FscacheClearPrefer`
7473    ///
7474    /// <details><summary>JSON schema</summary>
7475    ///
7476    /// ```json
7477    ///{
7478    ///  "type": "string",
7479    ///  "enum": [
7480    ///    "respond-async"
7481    ///  ]
7482    ///}
7483    /// ```
7484    /// </details>
7485    #[derive(
7486        :: serde :: Deserialize,
7487        :: serde :: Serialize,
7488        Clone,
7489        Copy,
7490        Debug,
7491        Eq,
7492        Hash,
7493        Ord,
7494        PartialEq,
7495        PartialOrd,
7496    )]
7497    pub enum FscacheClearPrefer {
7498        #[serde(rename = "respond-async")]
7499        RespondAsync,
7500    }
7501
7502    impl ::std::convert::From<&Self> for FscacheClearPrefer {
7503        fn from(value: &FscacheClearPrefer) -> Self {
7504            value.clone()
7505        }
7506    }
7507
7508    impl ::std::fmt::Display for FscacheClearPrefer {
7509        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7510            match *self {
7511                Self::RespondAsync => f.write_str("respond-async"),
7512            }
7513        }
7514    }
7515
7516    impl ::std::str::FromStr for FscacheClearPrefer {
7517        type Err = self::error::ConversionError;
7518        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7519            match value {
7520                "respond-async" => Ok(Self::RespondAsync),
7521                _ => Err("invalid value".into()),
7522            }
7523        }
7524    }
7525
7526    impl ::std::convert::TryFrom<&str> for FscacheClearPrefer {
7527        type Error = self::error::ConversionError;
7528        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7529            value.parse()
7530        }
7531    }
7532
7533    impl ::std::convert::TryFrom<&::std::string::String> for FscacheClearPrefer {
7534        type Error = self::error::ConversionError;
7535        fn try_from(
7536            value: &::std::string::String,
7537        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7538            value.parse()
7539        }
7540    }
7541
7542    impl ::std::convert::TryFrom<::std::string::String> for FscacheClearPrefer {
7543        type Error = self::error::ConversionError;
7544        fn try_from(
7545            value: ::std::string::String,
7546        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7547            value.parse()
7548        }
7549    }
7550
7551    ///`FscacheClearRequest`
7552    ///
7553    /// <details><summary>JSON schema</summary>
7554    ///
7555    /// ```json
7556    ///{
7557    ///  "type": "object",
7558    ///  "properties": {
7559    ///    "_async": {
7560    ///      "description": "Run the command asynchronously. Returns a job id
7561    /// immediately.",
7562    ///      "type": "boolean"
7563    ///    },
7564    ///    "_group": {
7565    ///      "description": "Assign the request to a custom stats group.",
7566    ///      "type": "string"
7567    ///    }
7568    ///  }
7569    ///}
7570    /// ```
7571    /// </details>
7572    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7573    pub struct FscacheClearRequest {
7574        ///Run the command asynchronously. Returns a job id immediately.
7575        #[serde(
7576            rename = "_async",
7577            default,
7578            skip_serializing_if = "::std::option::Option::is_none"
7579        )]
7580        pub async_: ::std::option::Option<bool>,
7581        ///Assign the request to a custom stats group.
7582        #[serde(
7583            rename = "_group",
7584            default,
7585            skip_serializing_if = "::std::option::Option::is_none"
7586        )]
7587        pub group: ::std::option::Option<::std::string::String>,
7588    }
7589
7590    impl ::std::convert::From<&FscacheClearRequest> for FscacheClearRequest {
7591        fn from(value: &FscacheClearRequest) -> Self {
7592            value.clone()
7593        }
7594    }
7595
7596    impl ::std::default::Default for FscacheClearRequest {
7597        fn default() -> Self {
7598            Self {
7599                async_: Default::default(),
7600                group: Default::default(),
7601            }
7602        }
7603    }
7604
7605    ///`FscacheEntriesPrefer`
7606    ///
7607    /// <details><summary>JSON schema</summary>
7608    ///
7609    /// ```json
7610    ///{
7611    ///  "type": "string",
7612    ///  "enum": [
7613    ///    "respond-async"
7614    ///  ]
7615    ///}
7616    /// ```
7617    /// </details>
7618    #[derive(
7619        :: serde :: Deserialize,
7620        :: serde :: Serialize,
7621        Clone,
7622        Copy,
7623        Debug,
7624        Eq,
7625        Hash,
7626        Ord,
7627        PartialEq,
7628        PartialOrd,
7629    )]
7630    pub enum FscacheEntriesPrefer {
7631        #[serde(rename = "respond-async")]
7632        RespondAsync,
7633    }
7634
7635    impl ::std::convert::From<&Self> for FscacheEntriesPrefer {
7636        fn from(value: &FscacheEntriesPrefer) -> Self {
7637            value.clone()
7638        }
7639    }
7640
7641    impl ::std::fmt::Display for FscacheEntriesPrefer {
7642        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7643            match *self {
7644                Self::RespondAsync => f.write_str("respond-async"),
7645            }
7646        }
7647    }
7648
7649    impl ::std::str::FromStr for FscacheEntriesPrefer {
7650        type Err = self::error::ConversionError;
7651        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7652            match value {
7653                "respond-async" => Ok(Self::RespondAsync),
7654                _ => Err("invalid value".into()),
7655            }
7656        }
7657    }
7658
7659    impl ::std::convert::TryFrom<&str> for FscacheEntriesPrefer {
7660        type Error = self::error::ConversionError;
7661        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7662            value.parse()
7663        }
7664    }
7665
7666    impl ::std::convert::TryFrom<&::std::string::String> for FscacheEntriesPrefer {
7667        type Error = self::error::ConversionError;
7668        fn try_from(
7669            value: &::std::string::String,
7670        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7671            value.parse()
7672        }
7673    }
7674
7675    impl ::std::convert::TryFrom<::std::string::String> for FscacheEntriesPrefer {
7676        type Error = self::error::ConversionError;
7677        fn try_from(
7678            value: ::std::string::String,
7679        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7680            value.parse()
7681        }
7682    }
7683
7684    ///`FscacheEntriesRequest`
7685    ///
7686    /// <details><summary>JSON schema</summary>
7687    ///
7688    /// ```json
7689    ///{
7690    ///  "type": "object",
7691    ///  "properties": {
7692    ///    "_async": {
7693    ///      "description": "Run the command asynchronously. Returns a job id
7694    /// immediately.",
7695    ///      "type": "boolean"
7696    ///    },
7697    ///    "_group": {
7698    ///      "description": "Assign the request to a custom stats group.",
7699    ///      "type": "string"
7700    ///    }
7701    ///  }
7702    ///}
7703    /// ```
7704    /// </details>
7705    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7706    pub struct FscacheEntriesRequest {
7707        ///Run the command asynchronously. Returns a job id immediately.
7708        #[serde(
7709            rename = "_async",
7710            default,
7711            skip_serializing_if = "::std::option::Option::is_none"
7712        )]
7713        pub async_: ::std::option::Option<bool>,
7714        ///Assign the request to a custom stats group.
7715        #[serde(
7716            rename = "_group",
7717            default,
7718            skip_serializing_if = "::std::option::Option::is_none"
7719        )]
7720        pub group: ::std::option::Option<::std::string::String>,
7721    }
7722
7723    impl ::std::convert::From<&FscacheEntriesRequest> for FscacheEntriesRequest {
7724        fn from(value: &FscacheEntriesRequest) -> Self {
7725            value.clone()
7726        }
7727    }
7728
7729    impl ::std::default::Default for FscacheEntriesRequest {
7730        fn default() -> Self {
7731            Self {
7732                async_: Default::default(),
7733                group: Default::default(),
7734            }
7735        }
7736    }
7737
7738    ///`FscacheEntriesResponse`
7739    ///
7740    /// <details><summary>JSON schema</summary>
7741    ///
7742    /// ```json
7743    ///{
7744    ///  "type": "object",
7745    ///  "required": [
7746    ///    "entries"
7747    ///  ],
7748    ///  "properties": {
7749    ///    "entries": {
7750    ///      "type": "integer"
7751    ///    }
7752    ///  }
7753    ///}
7754    /// ```
7755    /// </details>
7756    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7757    pub struct FscacheEntriesResponse {
7758        pub entries: i64,
7759    }
7760
7761    impl ::std::convert::From<&FscacheEntriesResponse> for FscacheEntriesResponse {
7762        fn from(value: &FscacheEntriesResponse) -> Self {
7763            value.clone()
7764        }
7765    }
7766
7767    ///`JobBatchInputsItem`
7768    ///
7769    /// <details><summary>JSON schema</summary>
7770    ///
7771    /// ```json
7772    ///{
7773    ///  "type": "object",
7774    ///  "required": [
7775    ///    "_path"
7776    ///  ],
7777    ///  "properties": {
7778    ///    "_path": {
7779    ///      "description": "rc/path",
7780    ///      "type": "string"
7781    ///    }
7782    ///  },
7783    ///  "additionalProperties": true
7784    ///}
7785    /// ```
7786    /// </details>
7787    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7788    pub struct JobBatchInputsItem {
7789        ///rc/path
7790        #[serde(rename = "_path")]
7791        pub path: ::std::string::String,
7792    }
7793
7794    impl ::std::convert::From<&JobBatchInputsItem> for JobBatchInputsItem {
7795        fn from(value: &JobBatchInputsItem) -> Self {
7796            value.clone()
7797        }
7798    }
7799
7800    ///`JobBatchPrefer`
7801    ///
7802    /// <details><summary>JSON schema</summary>
7803    ///
7804    /// ```json
7805    ///{
7806    ///  "type": "string",
7807    ///  "enum": [
7808    ///    "respond-async"
7809    ///  ]
7810    ///}
7811    /// ```
7812    /// </details>
7813    #[derive(
7814        :: serde :: Deserialize,
7815        :: serde :: Serialize,
7816        Clone,
7817        Copy,
7818        Debug,
7819        Eq,
7820        Hash,
7821        Ord,
7822        PartialEq,
7823        PartialOrd,
7824    )]
7825    pub enum JobBatchPrefer {
7826        #[serde(rename = "respond-async")]
7827        RespondAsync,
7828    }
7829
7830    impl ::std::convert::From<&Self> for JobBatchPrefer {
7831        fn from(value: &JobBatchPrefer) -> Self {
7832            value.clone()
7833        }
7834    }
7835
7836    impl ::std::fmt::Display for JobBatchPrefer {
7837        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7838            match *self {
7839                Self::RespondAsync => f.write_str("respond-async"),
7840            }
7841        }
7842    }
7843
7844    impl ::std::str::FromStr for JobBatchPrefer {
7845        type Err = self::error::ConversionError;
7846        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7847            match value {
7848                "respond-async" => Ok(Self::RespondAsync),
7849                _ => Err("invalid value".into()),
7850            }
7851        }
7852    }
7853
7854    impl ::std::convert::TryFrom<&str> for JobBatchPrefer {
7855        type Error = self::error::ConversionError;
7856        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
7857            value.parse()
7858        }
7859    }
7860
7861    impl ::std::convert::TryFrom<&::std::string::String> for JobBatchPrefer {
7862        type Error = self::error::ConversionError;
7863        fn try_from(
7864            value: &::std::string::String,
7865        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7866            value.parse()
7867        }
7868    }
7869
7870    impl ::std::convert::TryFrom<::std::string::String> for JobBatchPrefer {
7871        type Error = self::error::ConversionError;
7872        fn try_from(
7873            value: ::std::string::String,
7874        ) -> ::std::result::Result<Self, self::error::ConversionError> {
7875            value.parse()
7876        }
7877    }
7878
7879    ///`JobBatchRequest`
7880    ///
7881    /// <details><summary>JSON schema</summary>
7882    ///
7883    /// ```json
7884    ///{
7885    ///  "type": "object",
7886    ///  "properties": {
7887    ///    "_async": {
7888    ///      "description": "Run the command asynchronously. Returns a job id
7889    /// immediately.",
7890    ///      "type": "boolean"
7891    ///    },
7892    ///    "_group": {
7893    ///      "description": "Stats group this batch accumulates under.",
7894    ///      "type": "string"
7895    ///    },
7896    ///    "concurrency": {
7897    ///      "description": "Do this many commands concurrently. Defaults to
7898    /// --transfers if not set.",
7899    ///      "type": "integer"
7900    ///    },
7901    ///    "inputs": {
7902    ///      "description": "List of inputs to the commands with an extra _path
7903    /// parameter.",
7904    ///      "type": "array",
7905    ///      "items": {
7906    ///        "type": "object",
7907    ///        "required": [
7908    ///          "_path"
7909    ///        ],
7910    ///        "properties": {
7911    ///          "_group": {
7912    ///            "description": "Stats group this input accumulates under.",
7913    ///            "type": "string"
7914    ///          },
7915    ///          "_path": {
7916    ///            "description": "rc/path",
7917    ///            "type": "string"
7918    ///          }
7919    ///        },
7920    ///        "additionalProperties": true
7921    ///      }
7922    ///    }
7923    ///  }
7924    ///}
7925    /// ```
7926    /// </details>
7927    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7928    pub struct JobBatchRequest {
7929        ///Run the command asynchronously. Returns a job id immediately.
7930        #[serde(
7931            rename = "_async",
7932            default,
7933            skip_serializing_if = "::std::option::Option::is_none"
7934        )]
7935        pub async_: ::std::option::Option<bool>,
7936        ///Do this many commands concurrently. Defaults to --transfers if not
7937        /// set.
7938        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7939        pub concurrency: ::std::option::Option<i64>,
7940        ///Stats group this batch accumulates under.
7941        #[serde(
7942            rename = "_group",
7943            default,
7944            skip_serializing_if = "::std::option::Option::is_none"
7945        )]
7946        pub group: ::std::option::Option<::std::string::String>,
7947        ///List of inputs to the commands with an extra _path parameter.
7948        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7949        pub inputs: ::std::vec::Vec<JobBatchRequestInputsItem>,
7950    }
7951
7952    impl ::std::convert::From<&JobBatchRequest> for JobBatchRequest {
7953        fn from(value: &JobBatchRequest) -> Self {
7954            value.clone()
7955        }
7956    }
7957
7958    impl ::std::default::Default for JobBatchRequest {
7959        fn default() -> Self {
7960            Self {
7961                async_: Default::default(),
7962                concurrency: Default::default(),
7963                group: Default::default(),
7964                inputs: Default::default(),
7965            }
7966        }
7967    }
7968
7969    ///`JobBatchRequestInputsItem`
7970    ///
7971    /// <details><summary>JSON schema</summary>
7972    ///
7973    /// ```json
7974    ///{
7975    ///  "type": "object",
7976    ///  "required": [
7977    ///    "_path"
7978    ///  ],
7979    ///  "properties": {
7980    ///    "_group": {
7981    ///      "description": "Stats group this input accumulates under.",
7982    ///      "type": "string"
7983    ///    },
7984    ///    "_path": {
7985    ///      "description": "rc/path",
7986    ///      "type": "string"
7987    ///    }
7988    ///  },
7989    ///  "additionalProperties": true
7990    ///}
7991    /// ```
7992    /// </details>
7993    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7994    pub struct JobBatchRequestInputsItem {
7995        ///Stats group this input accumulates under.
7996        #[serde(
7997            rename = "_group",
7998            default,
7999            skip_serializing_if = "::std::option::Option::is_none"
8000        )]
8001        pub group: ::std::option::Option<::std::string::String>,
8002        ///rc/path
8003        #[serde(rename = "_path")]
8004        pub path: ::std::string::String,
8005    }
8006
8007    impl ::std::convert::From<&JobBatchRequestInputsItem> for JobBatchRequestInputsItem {
8008        fn from(value: &JobBatchRequestInputsItem) -> Self {
8009            value.clone()
8010        }
8011    }
8012
8013    ///`JobBatchResponse`
8014    ///
8015    /// <details><summary>JSON schema</summary>
8016    ///
8017    /// ```json
8018    ///{
8019    ///  "type": "object",
8020    ///  "required": [
8021    ///    "executeId",
8022    ///    "jobid"
8023    ///  ],
8024    ///  "properties": {
8025    ///    "executeId": {
8026    ///      "description": "Identifier for this rclone process.",
8027    ///      "type": "string"
8028    ///    },
8029    ///    "jobid": {
8030    ///      "description": "ID of the async job.",
8031    ///      "type": "integer"
8032    ///    }
8033    ///  }
8034    ///}
8035    /// ```
8036    /// </details>
8037    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8038    pub struct JobBatchResponse {
8039        ///Identifier for this rclone process.
8040        #[serde(rename = "executeId")]
8041        pub execute_id: ::std::string::String,
8042        ///ID of the async job.
8043        pub jobid: i64,
8044    }
8045
8046    impl ::std::convert::From<&JobBatchResponse> for JobBatchResponse {
8047        fn from(value: &JobBatchResponse) -> Self {
8048            value.clone()
8049        }
8050    }
8051
8052    ///`JobListPrefer`
8053    ///
8054    /// <details><summary>JSON schema</summary>
8055    ///
8056    /// ```json
8057    ///{
8058    ///  "type": "string",
8059    ///  "enum": [
8060    ///    "respond-async"
8061    ///  ]
8062    ///}
8063    /// ```
8064    /// </details>
8065    #[derive(
8066        :: serde :: Deserialize,
8067        :: serde :: Serialize,
8068        Clone,
8069        Copy,
8070        Debug,
8071        Eq,
8072        Hash,
8073        Ord,
8074        PartialEq,
8075        PartialOrd,
8076    )]
8077    pub enum JobListPrefer {
8078        #[serde(rename = "respond-async")]
8079        RespondAsync,
8080    }
8081
8082    impl ::std::convert::From<&Self> for JobListPrefer {
8083        fn from(value: &JobListPrefer) -> Self {
8084            value.clone()
8085        }
8086    }
8087
8088    impl ::std::fmt::Display for JobListPrefer {
8089        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8090            match *self {
8091                Self::RespondAsync => f.write_str("respond-async"),
8092            }
8093        }
8094    }
8095
8096    impl ::std::str::FromStr for JobListPrefer {
8097        type Err = self::error::ConversionError;
8098        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8099            match value {
8100                "respond-async" => Ok(Self::RespondAsync),
8101                _ => Err("invalid value".into()),
8102            }
8103        }
8104    }
8105
8106    impl ::std::convert::TryFrom<&str> for JobListPrefer {
8107        type Error = self::error::ConversionError;
8108        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8109            value.parse()
8110        }
8111    }
8112
8113    impl ::std::convert::TryFrom<&::std::string::String> for JobListPrefer {
8114        type Error = self::error::ConversionError;
8115        fn try_from(
8116            value: &::std::string::String,
8117        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8118            value.parse()
8119        }
8120    }
8121
8122    impl ::std::convert::TryFrom<::std::string::String> for JobListPrefer {
8123        type Error = self::error::ConversionError;
8124        fn try_from(
8125            value: ::std::string::String,
8126        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8127            value.parse()
8128        }
8129    }
8130
8131    ///`JobListRequest`
8132    ///
8133    /// <details><summary>JSON schema</summary>
8134    ///
8135    /// ```json
8136    ///{
8137    ///  "type": "object",
8138    ///  "properties": {
8139    ///    "_async": {
8140    ///      "description": "Run the command asynchronously. Returns a job id
8141    /// immediately.",
8142    ///      "type": "boolean"
8143    ///    }
8144    ///  }
8145    ///}
8146    /// ```
8147    /// </details>
8148    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8149    pub struct JobListRequest {
8150        ///Run the command asynchronously. Returns a job id immediately.
8151        #[serde(
8152            rename = "_async",
8153            default,
8154            skip_serializing_if = "::std::option::Option::is_none"
8155        )]
8156        pub async_: ::std::option::Option<bool>,
8157    }
8158
8159    impl ::std::convert::From<&JobListRequest> for JobListRequest {
8160        fn from(value: &JobListRequest) -> Self {
8161            value.clone()
8162        }
8163    }
8164
8165    impl ::std::default::Default for JobListRequest {
8166        fn default() -> Self {
8167            Self {
8168                async_: Default::default(),
8169            }
8170        }
8171    }
8172
8173    ///`JobListResponse`
8174    ///
8175    /// <details><summary>JSON schema</summary>
8176    ///
8177    /// ```json
8178    ///{
8179    ///  "type": "object",
8180    ///  "required": [
8181    ///    "executeId",
8182    ///    "finishedIds",
8183    ///    "jobids",
8184    ///    "runningIds"
8185    ///  ],
8186    ///  "properties": {
8187    ///    "executeId": {
8188    ///      "description": "Identifier for this rclone process.",
8189    ///      "type": "string"
8190    ///    },
8191    ///    "finishedIds": {
8192    ///      "description": "Array of integer job ids that are finished.",
8193    ///      "type": "array",
8194    ///      "items": {
8195    ///        "type": "integer"
8196    ///      }
8197    ///    },
8198    ///    "jobids": {
8199    ///      "description": "Job IDs suitable for use with `job/status` and
8200    /// `job/stop`.",
8201    ///      "type": "array",
8202    ///      "items": {
8203    ///        "type": "number"
8204    ///      }
8205    ///    },
8206    ///    "runningIds": {
8207    ///      "description": "Array of integer job ids that are running.",
8208    ///      "type": "array",
8209    ///      "items": {
8210    ///        "type": "integer"
8211    ///      }
8212    ///    }
8213    ///  }
8214    ///}
8215    /// ```
8216    /// </details>
8217    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8218    pub struct JobListResponse {
8219        ///Identifier for this rclone process.
8220        #[serde(rename = "executeId")]
8221        pub execute_id: ::std::string::String,
8222        ///Array of integer job ids that are finished.
8223        #[serde(rename = "finishedIds")]
8224        pub finished_ids: ::std::vec::Vec<i64>,
8225        ///Job IDs suitable for use with `job/status` and `job/stop`.
8226        pub jobids: ::std::vec::Vec<f64>,
8227        ///Array of integer job ids that are running.
8228        #[serde(rename = "runningIds")]
8229        pub running_ids: ::std::vec::Vec<i64>,
8230    }
8231
8232    impl ::std::convert::From<&JobListResponse> for JobListResponse {
8233        fn from(value: &JobListResponse) -> Self {
8234            value.clone()
8235        }
8236    }
8237
8238    ///`JobStatusPrefer`
8239    ///
8240    /// <details><summary>JSON schema</summary>
8241    ///
8242    /// ```json
8243    ///{
8244    ///  "type": "string",
8245    ///  "enum": [
8246    ///    "respond-async"
8247    ///  ]
8248    ///}
8249    /// ```
8250    /// </details>
8251    #[derive(
8252        :: serde :: Deserialize,
8253        :: serde :: Serialize,
8254        Clone,
8255        Copy,
8256        Debug,
8257        Eq,
8258        Hash,
8259        Ord,
8260        PartialEq,
8261        PartialOrd,
8262    )]
8263    pub enum JobStatusPrefer {
8264        #[serde(rename = "respond-async")]
8265        RespondAsync,
8266    }
8267
8268    impl ::std::convert::From<&Self> for JobStatusPrefer {
8269        fn from(value: &JobStatusPrefer) -> Self {
8270            value.clone()
8271        }
8272    }
8273
8274    impl ::std::fmt::Display for JobStatusPrefer {
8275        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8276            match *self {
8277                Self::RespondAsync => f.write_str("respond-async"),
8278            }
8279        }
8280    }
8281
8282    impl ::std::str::FromStr for JobStatusPrefer {
8283        type Err = self::error::ConversionError;
8284        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8285            match value {
8286                "respond-async" => Ok(Self::RespondAsync),
8287                _ => Err("invalid value".into()),
8288            }
8289        }
8290    }
8291
8292    impl ::std::convert::TryFrom<&str> for JobStatusPrefer {
8293        type Error = self::error::ConversionError;
8294        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8295            value.parse()
8296        }
8297    }
8298
8299    impl ::std::convert::TryFrom<&::std::string::String> for JobStatusPrefer {
8300        type Error = self::error::ConversionError;
8301        fn try_from(
8302            value: &::std::string::String,
8303        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8304            value.parse()
8305        }
8306    }
8307
8308    impl ::std::convert::TryFrom<::std::string::String> for JobStatusPrefer {
8309        type Error = self::error::ConversionError;
8310        fn try_from(
8311            value: ::std::string::String,
8312        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8313            value.parse()
8314        }
8315    }
8316
8317    ///`JobStatusRequest`
8318    ///
8319    /// <details><summary>JSON schema</summary>
8320    ///
8321    /// ```json
8322    ///{
8323    ///  "type": "object",
8324    ///  "properties": {
8325    ///    "_async": {
8326    ///      "description": "Run the command asynchronously. Returns a job id
8327    /// immediately.",
8328    ///      "type": "boolean"
8329    ///    },
8330    ///    "jobid": {
8331    ///      "description": "Numeric identifier of the job to query, as returned
8332    /// from an async call.",
8333    ///      "type": "number"
8334    ///    }
8335    ///  }
8336    ///}
8337    /// ```
8338    /// </details>
8339    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8340    pub struct JobStatusRequest {
8341        ///Run the command asynchronously. Returns a job id immediately.
8342        #[serde(
8343            rename = "_async",
8344            default,
8345            skip_serializing_if = "::std::option::Option::is_none"
8346        )]
8347        pub async_: ::std::option::Option<bool>,
8348        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8349        pub jobid: ::std::option::Option<f64>,
8350    }
8351
8352    impl ::std::convert::From<&JobStatusRequest> for JobStatusRequest {
8353        fn from(value: &JobStatusRequest) -> Self {
8354            value.clone()
8355        }
8356    }
8357
8358    impl ::std::default::Default for JobStatusRequest {
8359        fn default() -> Self {
8360            Self {
8361                async_: Default::default(),
8362                jobid: Default::default(),
8363            }
8364        }
8365    }
8366
8367    ///`JobStatusResponse`
8368    ///
8369    /// <details><summary>JSON schema</summary>
8370    ///
8371    /// ```json
8372    ///{
8373    ///  "type": "object",
8374    ///  "required": [
8375    ///    "duration",
8376    ///    "endTime",
8377    ///    "error",
8378    ///    "executeId",
8379    ///    "finished",
8380    ///    "id",
8381    ///    "startTime",
8382    ///    "success"
8383    ///  ],
8384    ///  "properties": {
8385    ///    "duration": {
8386    ///      "description": "Execution time in seconds.",
8387    ///      "type": "number"
8388    ///    },
8389    ///    "endTime": {
8390    ///      "description": "Timestamp when the job finished. (e.g.
8391    /// '2025-12-26T18:50:20.528746884+01:00')",
8392    ///      "type": "string"
8393    ///    },
8394    ///    "error": {
8395    ///      "description": "Error message, or empty string on success.",
8396    ///      "type": "string"
8397    ///    },
8398    ///    "executeId": {
8399    ///      "description": "Identifier for this rclone process.",
8400    ///      "type": "string"
8401    ///    },
8402    ///    "finished": {
8403    ///      "description": "True once the job has completed.",
8404    ///      "type": "boolean"
8405    ///    },
8406    ///    "id": {
8407    ///      "description": "Job identifier.",
8408    ///      "type": "number"
8409    ///    },
8410    ///    "output": {
8411    ///      "description": "Synchronous-style output payload when available."
8412    ///    },
8413    ///    "progress": {
8414    ///      "description": "Progress measurements supplied by the underlying
8415    /// command."
8416    ///    },
8417    ///    "startTime": {
8418    ///      "description": "Timestamp when the job started. (e.g.
8419    /// '2025-12-24T18:50:20.5281314+01:00')",
8420    ///      "type": "string"
8421    ///    },
8422    ///    "success": {
8423    ///      "description": "True if the job completed successfully.",
8424    ///      "type": "boolean"
8425    ///    }
8426    ///  }
8427    ///}
8428    /// ```
8429    /// </details>
8430    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8431    pub struct JobStatusResponse {
8432        pub duration: f64,
8433        ///Timestamp when the job finished. (e.g.
8434        /// '2025-12-26T18:50:20.528746884+01:00')
8435        #[serde(rename = "endTime")]
8436        pub end_time: ::std::string::String,
8437        ///Error message, or empty string on success.
8438        pub error: ::std::string::String,
8439        ///Identifier for this rclone process.
8440        #[serde(rename = "executeId")]
8441        pub execute_id: ::std::string::String,
8442        ///True once the job has completed.
8443        pub finished: bool,
8444        pub id: f64,
8445        ///Synchronous-style output payload when available.
8446        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8447        pub output: ::std::option::Option<::serde_json::Value>,
8448        ///Progress measurements supplied by the underlying command.
8449        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8450        pub progress: ::std::option::Option<::serde_json::Value>,
8451        ///Timestamp when the job started. (e.g.
8452        /// '2025-12-24T18:50:20.5281314+01:00')
8453        #[serde(rename = "startTime")]
8454        pub start_time: ::std::string::String,
8455        ///True if the job completed successfully.
8456        pub success: bool,
8457    }
8458
8459    impl ::std::convert::From<&JobStatusResponse> for JobStatusResponse {
8460        fn from(value: &JobStatusResponse) -> Self {
8461            value.clone()
8462        }
8463    }
8464
8465    ///`JobStopPrefer`
8466    ///
8467    /// <details><summary>JSON schema</summary>
8468    ///
8469    /// ```json
8470    ///{
8471    ///  "type": "string",
8472    ///  "enum": [
8473    ///    "respond-async"
8474    ///  ]
8475    ///}
8476    /// ```
8477    /// </details>
8478    #[derive(
8479        :: serde :: Deserialize,
8480        :: serde :: Serialize,
8481        Clone,
8482        Copy,
8483        Debug,
8484        Eq,
8485        Hash,
8486        Ord,
8487        PartialEq,
8488        PartialOrd,
8489    )]
8490    pub enum JobStopPrefer {
8491        #[serde(rename = "respond-async")]
8492        RespondAsync,
8493    }
8494
8495    impl ::std::convert::From<&Self> for JobStopPrefer {
8496        fn from(value: &JobStopPrefer) -> Self {
8497            value.clone()
8498        }
8499    }
8500
8501    impl ::std::fmt::Display for JobStopPrefer {
8502        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8503            match *self {
8504                Self::RespondAsync => f.write_str("respond-async"),
8505            }
8506        }
8507    }
8508
8509    impl ::std::str::FromStr for JobStopPrefer {
8510        type Err = self::error::ConversionError;
8511        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8512            match value {
8513                "respond-async" => Ok(Self::RespondAsync),
8514                _ => Err("invalid value".into()),
8515            }
8516        }
8517    }
8518
8519    impl ::std::convert::TryFrom<&str> for JobStopPrefer {
8520        type Error = self::error::ConversionError;
8521        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8522            value.parse()
8523        }
8524    }
8525
8526    impl ::std::convert::TryFrom<&::std::string::String> for JobStopPrefer {
8527        type Error = self::error::ConversionError;
8528        fn try_from(
8529            value: &::std::string::String,
8530        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8531            value.parse()
8532        }
8533    }
8534
8535    impl ::std::convert::TryFrom<::std::string::String> for JobStopPrefer {
8536        type Error = self::error::ConversionError;
8537        fn try_from(
8538            value: ::std::string::String,
8539        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8540            value.parse()
8541        }
8542    }
8543
8544    ///`JobStopRequest`
8545    ///
8546    /// <details><summary>JSON schema</summary>
8547    ///
8548    /// ```json
8549    ///{
8550    ///  "type": "object",
8551    ///  "properties": {
8552    ///    "_async": {
8553    ///      "description": "Run the command asynchronously. Returns a job id
8554    /// immediately.",
8555    ///      "type": "boolean"
8556    ///    },
8557    ///    "jobid": {
8558    ///      "description": "Numeric identifier of the job to cancel.",
8559    ///      "type": "number"
8560    ///    }
8561    ///  }
8562    ///}
8563    /// ```
8564    /// </details>
8565    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8566    pub struct JobStopRequest {
8567        ///Run the command asynchronously. Returns a job id immediately.
8568        #[serde(
8569            rename = "_async",
8570            default,
8571            skip_serializing_if = "::std::option::Option::is_none"
8572        )]
8573        pub async_: ::std::option::Option<bool>,
8574        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8575        pub jobid: ::std::option::Option<f64>,
8576    }
8577
8578    impl ::std::convert::From<&JobStopRequest> for JobStopRequest {
8579        fn from(value: &JobStopRequest) -> Self {
8580            value.clone()
8581        }
8582    }
8583
8584    impl ::std::default::Default for JobStopRequest {
8585        fn default() -> Self {
8586            Self {
8587                async_: Default::default(),
8588                jobid: Default::default(),
8589            }
8590        }
8591    }
8592
8593    ///`JobStopgroupPrefer`
8594    ///
8595    /// <details><summary>JSON schema</summary>
8596    ///
8597    /// ```json
8598    ///{
8599    ///  "type": "string",
8600    ///  "enum": [
8601    ///    "respond-async"
8602    ///  ]
8603    ///}
8604    /// ```
8605    /// </details>
8606    #[derive(
8607        :: serde :: Deserialize,
8608        :: serde :: Serialize,
8609        Clone,
8610        Copy,
8611        Debug,
8612        Eq,
8613        Hash,
8614        Ord,
8615        PartialEq,
8616        PartialOrd,
8617    )]
8618    pub enum JobStopgroupPrefer {
8619        #[serde(rename = "respond-async")]
8620        RespondAsync,
8621    }
8622
8623    impl ::std::convert::From<&Self> for JobStopgroupPrefer {
8624        fn from(value: &JobStopgroupPrefer) -> Self {
8625            value.clone()
8626        }
8627    }
8628
8629    impl ::std::fmt::Display for JobStopgroupPrefer {
8630        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8631            match *self {
8632                Self::RespondAsync => f.write_str("respond-async"),
8633            }
8634        }
8635    }
8636
8637    impl ::std::str::FromStr for JobStopgroupPrefer {
8638        type Err = self::error::ConversionError;
8639        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8640            match value {
8641                "respond-async" => Ok(Self::RespondAsync),
8642                _ => Err("invalid value".into()),
8643            }
8644        }
8645    }
8646
8647    impl ::std::convert::TryFrom<&str> for JobStopgroupPrefer {
8648        type Error = self::error::ConversionError;
8649        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8650            value.parse()
8651        }
8652    }
8653
8654    impl ::std::convert::TryFrom<&::std::string::String> for JobStopgroupPrefer {
8655        type Error = self::error::ConversionError;
8656        fn try_from(
8657            value: &::std::string::String,
8658        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8659            value.parse()
8660        }
8661    }
8662
8663    impl ::std::convert::TryFrom<::std::string::String> for JobStopgroupPrefer {
8664        type Error = self::error::ConversionError;
8665        fn try_from(
8666            value: ::std::string::String,
8667        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8668            value.parse()
8669        }
8670    }
8671
8672    ///`JobStopgroupRequest`
8673    ///
8674    /// <details><summary>JSON schema</summary>
8675    ///
8676    /// ```json
8677    ///{
8678    ///  "type": "object",
8679    ///  "properties": {
8680    ///    "_async": {
8681    ///      "description": "Run the command asynchronously. Returns a job id
8682    /// immediately.",
8683    ///      "type": "boolean"
8684    ///    },
8685    ///    "group": {
8686    ///      "description": "Stats group name whose active jobs should be
8687    /// stopped.",
8688    ///      "type": "string"
8689    ///    }
8690    ///  }
8691    ///}
8692    /// ```
8693    /// </details>
8694    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8695    pub struct JobStopgroupRequest {
8696        ///Run the command asynchronously. Returns a job id immediately.
8697        #[serde(
8698            rename = "_async",
8699            default,
8700            skip_serializing_if = "::std::option::Option::is_none"
8701        )]
8702        pub async_: ::std::option::Option<bool>,
8703        ///Stats group name whose active jobs should be stopped.
8704        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8705        pub group: ::std::option::Option<::std::string::String>,
8706    }
8707
8708    impl ::std::convert::From<&JobStopgroupRequest> for JobStopgroupRequest {
8709        fn from(value: &JobStopgroupRequest) -> Self {
8710            value.clone()
8711        }
8712    }
8713
8714    impl ::std::default::Default for JobStopgroupRequest {
8715        fn default() -> Self {
8716            Self {
8717                async_: Default::default(),
8718                group: Default::default(),
8719            }
8720        }
8721    }
8722
8723    ///`MountListmountsPrefer`
8724    ///
8725    /// <details><summary>JSON schema</summary>
8726    ///
8727    /// ```json
8728    ///{
8729    ///  "type": "string",
8730    ///  "enum": [
8731    ///    "respond-async"
8732    ///  ]
8733    ///}
8734    /// ```
8735    /// </details>
8736    #[derive(
8737        :: serde :: Deserialize,
8738        :: serde :: Serialize,
8739        Clone,
8740        Copy,
8741        Debug,
8742        Eq,
8743        Hash,
8744        Ord,
8745        PartialEq,
8746        PartialOrd,
8747    )]
8748    pub enum MountListmountsPrefer {
8749        #[serde(rename = "respond-async")]
8750        RespondAsync,
8751    }
8752
8753    impl ::std::convert::From<&Self> for MountListmountsPrefer {
8754        fn from(value: &MountListmountsPrefer) -> Self {
8755            value.clone()
8756        }
8757    }
8758
8759    impl ::std::fmt::Display for MountListmountsPrefer {
8760        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8761            match *self {
8762                Self::RespondAsync => f.write_str("respond-async"),
8763            }
8764        }
8765    }
8766
8767    impl ::std::str::FromStr for MountListmountsPrefer {
8768        type Err = self::error::ConversionError;
8769        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8770            match value {
8771                "respond-async" => Ok(Self::RespondAsync),
8772                _ => Err("invalid value".into()),
8773            }
8774        }
8775    }
8776
8777    impl ::std::convert::TryFrom<&str> for MountListmountsPrefer {
8778        type Error = self::error::ConversionError;
8779        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8780            value.parse()
8781        }
8782    }
8783
8784    impl ::std::convert::TryFrom<&::std::string::String> for MountListmountsPrefer {
8785        type Error = self::error::ConversionError;
8786        fn try_from(
8787            value: &::std::string::String,
8788        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8789            value.parse()
8790        }
8791    }
8792
8793    impl ::std::convert::TryFrom<::std::string::String> for MountListmountsPrefer {
8794        type Error = self::error::ConversionError;
8795        fn try_from(
8796            value: ::std::string::String,
8797        ) -> ::std::result::Result<Self, self::error::ConversionError> {
8798            value.parse()
8799        }
8800    }
8801
8802    ///`MountListmountsRequest`
8803    ///
8804    /// <details><summary>JSON schema</summary>
8805    ///
8806    /// ```json
8807    ///{
8808    ///  "type": "object",
8809    ///  "properties": {
8810    ///    "_async": {
8811    ///      "description": "Run the command asynchronously. Returns a job id
8812    /// immediately.",
8813    ///      "type": "boolean"
8814    ///    },
8815    ///    "_group": {
8816    ///      "description": "Assign the request to a custom stats group.",
8817    ///      "type": "string"
8818    ///    }
8819    ///  }
8820    ///}
8821    /// ```
8822    /// </details>
8823    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8824    pub struct MountListmountsRequest {
8825        ///Run the command asynchronously. Returns a job id immediately.
8826        #[serde(
8827            rename = "_async",
8828            default,
8829            skip_serializing_if = "::std::option::Option::is_none"
8830        )]
8831        pub async_: ::std::option::Option<bool>,
8832        ///Assign the request to a custom stats group.
8833        #[serde(
8834            rename = "_group",
8835            default,
8836            skip_serializing_if = "::std::option::Option::is_none"
8837        )]
8838        pub group: ::std::option::Option<::std::string::String>,
8839    }
8840
8841    impl ::std::convert::From<&MountListmountsRequest> for MountListmountsRequest {
8842        fn from(value: &MountListmountsRequest) -> Self {
8843            value.clone()
8844        }
8845    }
8846
8847    impl ::std::default::Default for MountListmountsRequest {
8848        fn default() -> Self {
8849            Self {
8850                async_: Default::default(),
8851                group: Default::default(),
8852            }
8853        }
8854    }
8855
8856    ///`MountListmountsResponse`
8857    ///
8858    /// <details><summary>JSON schema</summary>
8859    ///
8860    /// ```json
8861    ///{
8862    ///  "type": "object",
8863    ///  "required": [
8864    ///    "mountPoints"
8865    ///  ],
8866    ///  "properties": {
8867    ///    "mountPoints": {
8868    ///      "type": "array",
8869    ///      "items": {
8870    ///        "type": "object",
8871    ///        "required": [
8872    ///          "Fs",
8873    ///          "MountPoint",
8874    ///          "MountedOn"
8875    ///        ],
8876    ///        "properties": {
8877    ///          "Fs": {
8878    ///            "type": "string"
8879    ///          },
8880    ///          "MountPoint": {
8881    ///            "type": "string"
8882    ///          },
8883    ///          "MountedOn": {
8884    ///            "type": "string",
8885    ///            "format": "date-time"
8886    ///          }
8887    ///        },
8888    ///        "additionalProperties": false
8889    ///      }
8890    ///    }
8891    ///  }
8892    ///}
8893    /// ```
8894    /// </details>
8895    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8896    pub struct MountListmountsResponse {
8897        #[serde(rename = "mountPoints")]
8898        pub mount_points: ::std::vec::Vec<MountListmountsResponseMountPointsItem>,
8899    }
8900
8901    impl ::std::convert::From<&MountListmountsResponse> for MountListmountsResponse {
8902        fn from(value: &MountListmountsResponse) -> Self {
8903            value.clone()
8904        }
8905    }
8906
8907    ///`MountListmountsResponseMountPointsItem`
8908    ///
8909    /// <details><summary>JSON schema</summary>
8910    ///
8911    /// ```json
8912    ///{
8913    ///  "type": "object",
8914    ///  "required": [
8915    ///    "Fs",
8916    ///    "MountPoint",
8917    ///    "MountedOn"
8918    ///  ],
8919    ///  "properties": {
8920    ///    "Fs": {
8921    ///      "type": "string"
8922    ///    },
8923    ///    "MountPoint": {
8924    ///      "type": "string"
8925    ///    },
8926    ///    "MountedOn": {
8927    ///      "type": "string",
8928    ///      "format": "date-time"
8929    ///    }
8930    ///  },
8931    ///  "additionalProperties": false
8932    ///}
8933    /// ```
8934    /// </details>
8935    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8936    #[serde(deny_unknown_fields)]
8937    pub struct MountListmountsResponseMountPointsItem {
8938        #[serde(rename = "Fs")]
8939        pub fs: ::std::string::String,
8940        #[serde(rename = "MountPoint")]
8941        pub mount_point: ::std::string::String,
8942        #[serde(rename = "MountedOn")]
8943        pub mounted_on: ::chrono::DateTime<::chrono::offset::Utc>,
8944    }
8945
8946    impl ::std::convert::From<&MountListmountsResponseMountPointsItem>
8947        for MountListmountsResponseMountPointsItem
8948    {
8949        fn from(value: &MountListmountsResponseMountPointsItem) -> Self {
8950            value.clone()
8951        }
8952    }
8953
8954    ///`MountMountPrefer`
8955    ///
8956    /// <details><summary>JSON schema</summary>
8957    ///
8958    /// ```json
8959    ///{
8960    ///  "type": "string",
8961    ///  "enum": [
8962    ///    "respond-async"
8963    ///  ]
8964    ///}
8965    /// ```
8966    /// </details>
8967    #[derive(
8968        :: serde :: Deserialize,
8969        :: serde :: Serialize,
8970        Clone,
8971        Copy,
8972        Debug,
8973        Eq,
8974        Hash,
8975        Ord,
8976        PartialEq,
8977        PartialOrd,
8978    )]
8979    pub enum MountMountPrefer {
8980        #[serde(rename = "respond-async")]
8981        RespondAsync,
8982    }
8983
8984    impl ::std::convert::From<&Self> for MountMountPrefer {
8985        fn from(value: &MountMountPrefer) -> Self {
8986            value.clone()
8987        }
8988    }
8989
8990    impl ::std::fmt::Display for MountMountPrefer {
8991        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8992            match *self {
8993                Self::RespondAsync => f.write_str("respond-async"),
8994            }
8995        }
8996    }
8997
8998    impl ::std::str::FromStr for MountMountPrefer {
8999        type Err = self::error::ConversionError;
9000        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9001            match value {
9002                "respond-async" => Ok(Self::RespondAsync),
9003                _ => Err("invalid value".into()),
9004            }
9005        }
9006    }
9007
9008    impl ::std::convert::TryFrom<&str> for MountMountPrefer {
9009        type Error = self::error::ConversionError;
9010        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9011            value.parse()
9012        }
9013    }
9014
9015    impl ::std::convert::TryFrom<&::std::string::String> for MountMountPrefer {
9016        type Error = self::error::ConversionError;
9017        fn try_from(
9018            value: &::std::string::String,
9019        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9020            value.parse()
9021        }
9022    }
9023
9024    impl ::std::convert::TryFrom<::std::string::String> for MountMountPrefer {
9025        type Error = self::error::ConversionError;
9026        fn try_from(
9027            value: ::std::string::String,
9028        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9029            value.parse()
9030        }
9031    }
9032
9033    ///`MountMountRequest`
9034    ///
9035    /// <details><summary>JSON schema</summary>
9036    ///
9037    /// ```json
9038    ///{
9039    ///  "type": "object",
9040    ///  "properties": {
9041    ///    "_async": {
9042    ///      "description": "Run the command asynchronously. Returns a job id
9043    /// immediately.",
9044    ///      "type": "boolean"
9045    ///    },
9046    ///    "_config": {
9047    ///      "description": "JSON encoded config overrides applied for this call
9048    /// only.",
9049    ///      "type": "string"
9050    ///    },
9051    ///    "_filter": {
9052    ///      "description": "JSON encoded filter overrides applied for this call
9053    /// only.",
9054    ///      "type": "string"
9055    ///    },
9056    ///    "_group": {
9057    ///      "description": "Assign the request to a custom stats group.",
9058    ///      "type": "string"
9059    ///    },
9060    ///    "fs": {
9061    ///      "description": "Remote path to mount, such as `drive:` or
9062    /// `remote:subdir`.",
9063    ///      "type": "string"
9064    ///    },
9065    ///    "mountOpt": {
9066    ///      "description": "Mount options encoded as JSON, matching flags
9067    /// accepted by `rclone mount`.",
9068    ///      "type": "string"
9069    ///    },
9070    ///    "mountPoint": {
9071    ///      "description": "Absolute local path where the remote should be
9072    /// mounted.",
9073    ///      "type": "string"
9074    ///    },
9075    ///    "mountType": {
9076    ///      "description": "Optional mount implementation to use (`mount`,
9077    /// `cmount`, or `mount2`).",
9078    ///      "type": "string"
9079    ///    },
9080    ///    "vfsOpt": {
9081    ///      "description": "VFS options encoded as JSON, matching flags
9082    /// accepted by `rclone mount`.",
9083    ///      "type": "string"
9084    ///    }
9085    ///  }
9086    ///}
9087    /// ```
9088    /// </details>
9089    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9090    pub struct MountMountRequest {
9091        ///Run the command asynchronously. Returns a job id immediately.
9092        #[serde(
9093            rename = "_async",
9094            default,
9095            skip_serializing_if = "::std::option::Option::is_none"
9096        )]
9097        pub async_: ::std::option::Option<bool>,
9098        ///JSON encoded config overrides applied for this call only.
9099        #[serde(
9100            rename = "_config",
9101            default,
9102            skip_serializing_if = "::std::option::Option::is_none"
9103        )]
9104        pub config: ::std::option::Option<::std::string::String>,
9105        ///JSON encoded filter overrides applied for this call only.
9106        #[serde(
9107            rename = "_filter",
9108            default,
9109            skip_serializing_if = "::std::option::Option::is_none"
9110        )]
9111        pub filter: ::std::option::Option<::std::string::String>,
9112        ///Remote path to mount, such as `drive:` or `remote:subdir`.
9113        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9114        pub fs: ::std::option::Option<::std::string::String>,
9115        ///Assign the request to a custom stats group.
9116        #[serde(
9117            rename = "_group",
9118            default,
9119            skip_serializing_if = "::std::option::Option::is_none"
9120        )]
9121        pub group: ::std::option::Option<::std::string::String>,
9122        ///Mount options encoded as JSON, matching flags accepted by `rclone
9123        /// mount`.
9124        #[serde(
9125            rename = "mountOpt",
9126            default,
9127            skip_serializing_if = "::std::option::Option::is_none"
9128        )]
9129        pub mount_opt: ::std::option::Option<::std::string::String>,
9130        ///Absolute local path where the remote should be mounted.
9131        #[serde(
9132            rename = "mountPoint",
9133            default,
9134            skip_serializing_if = "::std::option::Option::is_none"
9135        )]
9136        pub mount_point: ::std::option::Option<::std::string::String>,
9137        ///Optional mount implementation to use (`mount`, `cmount`, or
9138        /// `mount2`).
9139        #[serde(
9140            rename = "mountType",
9141            default,
9142            skip_serializing_if = "::std::option::Option::is_none"
9143        )]
9144        pub mount_type: ::std::option::Option<::std::string::String>,
9145        ///VFS options encoded as JSON, matching flags accepted by `rclone
9146        /// mount`.
9147        #[serde(
9148            rename = "vfsOpt",
9149            default,
9150            skip_serializing_if = "::std::option::Option::is_none"
9151        )]
9152        pub vfs_opt: ::std::option::Option<::std::string::String>,
9153    }
9154
9155    impl ::std::convert::From<&MountMountRequest> for MountMountRequest {
9156        fn from(value: &MountMountRequest) -> Self {
9157            value.clone()
9158        }
9159    }
9160
9161    impl ::std::default::Default for MountMountRequest {
9162        fn default() -> Self {
9163            Self {
9164                async_: Default::default(),
9165                config: Default::default(),
9166                filter: Default::default(),
9167                fs: Default::default(),
9168                group: Default::default(),
9169                mount_opt: Default::default(),
9170                mount_point: Default::default(),
9171                mount_type: Default::default(),
9172                vfs_opt: Default::default(),
9173            }
9174        }
9175    }
9176
9177    ///`MountMountResponse`
9178    ///
9179    /// <details><summary>JSON schema</summary>
9180    ///
9181    /// ```json
9182    ///{
9183    ///  "type": "object",
9184    ///  "required": [
9185    ///    "mountPoint"
9186    ///  ],
9187    ///  "properties": {
9188    ///    "mountPoint": {
9189    ///      "description": "Actual local path where the remote was mounted. May
9190    /// differ from the requested path (e.g. when '*' is used on Windows).",
9191    ///      "type": "string"
9192    ///    }
9193    ///  }
9194    ///}
9195    /// ```
9196    /// </details>
9197    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9198    pub struct MountMountResponse {
9199        ///Actual local path where the remote was mounted. May differ from the
9200        /// requested path (e.g. when '*' is used on Windows).
9201        #[serde(rename = "mountPoint")]
9202        pub mount_point: ::std::string::String,
9203    }
9204
9205    impl ::std::convert::From<&MountMountResponse> for MountMountResponse {
9206        fn from(value: &MountMountResponse) -> Self {
9207            value.clone()
9208        }
9209    }
9210
9211    ///`MountTypesPrefer`
9212    ///
9213    /// <details><summary>JSON schema</summary>
9214    ///
9215    /// ```json
9216    ///{
9217    ///  "type": "string",
9218    ///  "enum": [
9219    ///    "respond-async"
9220    ///  ]
9221    ///}
9222    /// ```
9223    /// </details>
9224    #[derive(
9225        :: serde :: Deserialize,
9226        :: serde :: Serialize,
9227        Clone,
9228        Copy,
9229        Debug,
9230        Eq,
9231        Hash,
9232        Ord,
9233        PartialEq,
9234        PartialOrd,
9235    )]
9236    pub enum MountTypesPrefer {
9237        #[serde(rename = "respond-async")]
9238        RespondAsync,
9239    }
9240
9241    impl ::std::convert::From<&Self> for MountTypesPrefer {
9242        fn from(value: &MountTypesPrefer) -> Self {
9243            value.clone()
9244        }
9245    }
9246
9247    impl ::std::fmt::Display for MountTypesPrefer {
9248        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9249            match *self {
9250                Self::RespondAsync => f.write_str("respond-async"),
9251            }
9252        }
9253    }
9254
9255    impl ::std::str::FromStr for MountTypesPrefer {
9256        type Err = self::error::ConversionError;
9257        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9258            match value {
9259                "respond-async" => Ok(Self::RespondAsync),
9260                _ => Err("invalid value".into()),
9261            }
9262        }
9263    }
9264
9265    impl ::std::convert::TryFrom<&str> for MountTypesPrefer {
9266        type Error = self::error::ConversionError;
9267        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9268            value.parse()
9269        }
9270    }
9271
9272    impl ::std::convert::TryFrom<&::std::string::String> for MountTypesPrefer {
9273        type Error = self::error::ConversionError;
9274        fn try_from(
9275            value: &::std::string::String,
9276        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9277            value.parse()
9278        }
9279    }
9280
9281    impl ::std::convert::TryFrom<::std::string::String> for MountTypesPrefer {
9282        type Error = self::error::ConversionError;
9283        fn try_from(
9284            value: ::std::string::String,
9285        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9286            value.parse()
9287        }
9288    }
9289
9290    ///`MountTypesRequest`
9291    ///
9292    /// <details><summary>JSON schema</summary>
9293    ///
9294    /// ```json
9295    ///{
9296    ///  "type": "object",
9297    ///  "properties": {
9298    ///    "_async": {
9299    ///      "description": "Run the command asynchronously. Returns a job id
9300    /// immediately.",
9301    ///      "type": "boolean"
9302    ///    },
9303    ///    "_group": {
9304    ///      "description": "Assign the request to a custom stats group.",
9305    ///      "type": "string"
9306    ///    }
9307    ///  }
9308    ///}
9309    /// ```
9310    /// </details>
9311    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9312    pub struct MountTypesRequest {
9313        ///Run the command asynchronously. Returns a job id immediately.
9314        #[serde(
9315            rename = "_async",
9316            default,
9317            skip_serializing_if = "::std::option::Option::is_none"
9318        )]
9319        pub async_: ::std::option::Option<bool>,
9320        ///Assign the request to a custom stats group.
9321        #[serde(
9322            rename = "_group",
9323            default,
9324            skip_serializing_if = "::std::option::Option::is_none"
9325        )]
9326        pub group: ::std::option::Option<::std::string::String>,
9327    }
9328
9329    impl ::std::convert::From<&MountTypesRequest> for MountTypesRequest {
9330        fn from(value: &MountTypesRequest) -> Self {
9331            value.clone()
9332        }
9333    }
9334
9335    impl ::std::default::Default for MountTypesRequest {
9336        fn default() -> Self {
9337            Self {
9338                async_: Default::default(),
9339                group: Default::default(),
9340            }
9341        }
9342    }
9343
9344    ///`MountTypesResponse`
9345    ///
9346    /// <details><summary>JSON schema</summary>
9347    ///
9348    /// ```json
9349    ///{
9350    ///  "type": "object",
9351    ///  "required": [
9352    ///    "mountTypes"
9353    ///  ],
9354    ///  "properties": {
9355    ///    "mountTypes": {
9356    ///      "type": "array",
9357    ///      "items": {
9358    ///        "type": "string"
9359    ///      }
9360    ///    }
9361    ///  }
9362    ///}
9363    /// ```
9364    /// </details>
9365    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9366    pub struct MountTypesResponse {
9367        #[serde(rename = "mountTypes")]
9368        pub mount_types: ::std::vec::Vec<::std::string::String>,
9369    }
9370
9371    impl ::std::convert::From<&MountTypesResponse> for MountTypesResponse {
9372        fn from(value: &MountTypesResponse) -> Self {
9373            value.clone()
9374        }
9375    }
9376
9377    ///`MountUnmountPrefer`
9378    ///
9379    /// <details><summary>JSON schema</summary>
9380    ///
9381    /// ```json
9382    ///{
9383    ///  "type": "string",
9384    ///  "enum": [
9385    ///    "respond-async"
9386    ///  ]
9387    ///}
9388    /// ```
9389    /// </details>
9390    #[derive(
9391        :: serde :: Deserialize,
9392        :: serde :: Serialize,
9393        Clone,
9394        Copy,
9395        Debug,
9396        Eq,
9397        Hash,
9398        Ord,
9399        PartialEq,
9400        PartialOrd,
9401    )]
9402    pub enum MountUnmountPrefer {
9403        #[serde(rename = "respond-async")]
9404        RespondAsync,
9405    }
9406
9407    impl ::std::convert::From<&Self> for MountUnmountPrefer {
9408        fn from(value: &MountUnmountPrefer) -> Self {
9409            value.clone()
9410        }
9411    }
9412
9413    impl ::std::fmt::Display for MountUnmountPrefer {
9414        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9415            match *self {
9416                Self::RespondAsync => f.write_str("respond-async"),
9417            }
9418        }
9419    }
9420
9421    impl ::std::str::FromStr for MountUnmountPrefer {
9422        type Err = self::error::ConversionError;
9423        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9424            match value {
9425                "respond-async" => Ok(Self::RespondAsync),
9426                _ => Err("invalid value".into()),
9427            }
9428        }
9429    }
9430
9431    impl ::std::convert::TryFrom<&str> for MountUnmountPrefer {
9432        type Error = self::error::ConversionError;
9433        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9434            value.parse()
9435        }
9436    }
9437
9438    impl ::std::convert::TryFrom<&::std::string::String> for MountUnmountPrefer {
9439        type Error = self::error::ConversionError;
9440        fn try_from(
9441            value: &::std::string::String,
9442        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9443            value.parse()
9444        }
9445    }
9446
9447    impl ::std::convert::TryFrom<::std::string::String> for MountUnmountPrefer {
9448        type Error = self::error::ConversionError;
9449        fn try_from(
9450            value: ::std::string::String,
9451        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9452            value.parse()
9453        }
9454    }
9455
9456    ///`MountUnmountRequest`
9457    ///
9458    /// <details><summary>JSON schema</summary>
9459    ///
9460    /// ```json
9461    ///{
9462    ///  "type": "object",
9463    ///  "properties": {
9464    ///    "_async": {
9465    ///      "description": "Run the command asynchronously. Returns a job id
9466    /// immediately.",
9467    ///      "type": "boolean"
9468    ///    },
9469    ///    "_group": {
9470    ///      "description": "Assign the request to a custom stats group.",
9471    ///      "type": "string"
9472    ///    },
9473    ///    "mountPoint": {
9474    ///      "description": "Local mount point path to unmount.",
9475    ///      "type": "string"
9476    ///    }
9477    ///  }
9478    ///}
9479    /// ```
9480    /// </details>
9481    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9482    pub struct MountUnmountRequest {
9483        ///Run the command asynchronously. Returns a job id immediately.
9484        #[serde(
9485            rename = "_async",
9486            default,
9487            skip_serializing_if = "::std::option::Option::is_none"
9488        )]
9489        pub async_: ::std::option::Option<bool>,
9490        ///Assign the request to a custom stats group.
9491        #[serde(
9492            rename = "_group",
9493            default,
9494            skip_serializing_if = "::std::option::Option::is_none"
9495        )]
9496        pub group: ::std::option::Option<::std::string::String>,
9497        ///Local mount point path to unmount.
9498        #[serde(
9499            rename = "mountPoint",
9500            default,
9501            skip_serializing_if = "::std::option::Option::is_none"
9502        )]
9503        pub mount_point: ::std::option::Option<::std::string::String>,
9504    }
9505
9506    impl ::std::convert::From<&MountUnmountRequest> for MountUnmountRequest {
9507        fn from(value: &MountUnmountRequest) -> Self {
9508            value.clone()
9509        }
9510    }
9511
9512    impl ::std::default::Default for MountUnmountRequest {
9513        fn default() -> Self {
9514            Self {
9515                async_: Default::default(),
9516                group: Default::default(),
9517                mount_point: Default::default(),
9518            }
9519        }
9520    }
9521
9522    ///`MountUnmountallPrefer`
9523    ///
9524    /// <details><summary>JSON schema</summary>
9525    ///
9526    /// ```json
9527    ///{
9528    ///  "type": "string",
9529    ///  "enum": [
9530    ///    "respond-async"
9531    ///  ]
9532    ///}
9533    /// ```
9534    /// </details>
9535    #[derive(
9536        :: serde :: Deserialize,
9537        :: serde :: Serialize,
9538        Clone,
9539        Copy,
9540        Debug,
9541        Eq,
9542        Hash,
9543        Ord,
9544        PartialEq,
9545        PartialOrd,
9546    )]
9547    pub enum MountUnmountallPrefer {
9548        #[serde(rename = "respond-async")]
9549        RespondAsync,
9550    }
9551
9552    impl ::std::convert::From<&Self> for MountUnmountallPrefer {
9553        fn from(value: &MountUnmountallPrefer) -> Self {
9554            value.clone()
9555        }
9556    }
9557
9558    impl ::std::fmt::Display for MountUnmountallPrefer {
9559        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9560            match *self {
9561                Self::RespondAsync => f.write_str("respond-async"),
9562            }
9563        }
9564    }
9565
9566    impl ::std::str::FromStr for MountUnmountallPrefer {
9567        type Err = self::error::ConversionError;
9568        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9569            match value {
9570                "respond-async" => Ok(Self::RespondAsync),
9571                _ => Err("invalid value".into()),
9572            }
9573        }
9574    }
9575
9576    impl ::std::convert::TryFrom<&str> for MountUnmountallPrefer {
9577        type Error = self::error::ConversionError;
9578        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9579            value.parse()
9580        }
9581    }
9582
9583    impl ::std::convert::TryFrom<&::std::string::String> for MountUnmountallPrefer {
9584        type Error = self::error::ConversionError;
9585        fn try_from(
9586            value: &::std::string::String,
9587        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9588            value.parse()
9589        }
9590    }
9591
9592    impl ::std::convert::TryFrom<::std::string::String> for MountUnmountallPrefer {
9593        type Error = self::error::ConversionError;
9594        fn try_from(
9595            value: ::std::string::String,
9596        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9597            value.parse()
9598        }
9599    }
9600
9601    ///`MountUnmountallRequest`
9602    ///
9603    /// <details><summary>JSON schema</summary>
9604    ///
9605    /// ```json
9606    ///{
9607    ///  "type": "object",
9608    ///  "properties": {
9609    ///    "_async": {
9610    ///      "description": "Run the command asynchronously. Returns a job id
9611    /// immediately.",
9612    ///      "type": "boolean"
9613    ///    },
9614    ///    "_group": {
9615    ///      "description": "Assign the request to a custom stats group.",
9616    ///      "type": "string"
9617    ///    }
9618    ///  }
9619    ///}
9620    /// ```
9621    /// </details>
9622    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9623    pub struct MountUnmountallRequest {
9624        ///Run the command asynchronously. Returns a job id immediately.
9625        #[serde(
9626            rename = "_async",
9627            default,
9628            skip_serializing_if = "::std::option::Option::is_none"
9629        )]
9630        pub async_: ::std::option::Option<bool>,
9631        ///Assign the request to a custom stats group.
9632        #[serde(
9633            rename = "_group",
9634            default,
9635            skip_serializing_if = "::std::option::Option::is_none"
9636        )]
9637        pub group: ::std::option::Option<::std::string::String>,
9638    }
9639
9640    impl ::std::convert::From<&MountUnmountallRequest> for MountUnmountallRequest {
9641        fn from(value: &MountUnmountallRequest) -> Self {
9642            value.clone()
9643        }
9644    }
9645
9646    impl ::std::default::Default for MountUnmountallRequest {
9647        fn default() -> Self {
9648            Self {
9649                async_: Default::default(),
9650                group: Default::default(),
9651            }
9652        }
9653    }
9654
9655    ///`OperationsAboutPrefer`
9656    ///
9657    /// <details><summary>JSON schema</summary>
9658    ///
9659    /// ```json
9660    ///{
9661    ///  "type": "string",
9662    ///  "enum": [
9663    ///    "respond-async"
9664    ///  ]
9665    ///}
9666    /// ```
9667    /// </details>
9668    #[derive(
9669        :: serde :: Deserialize,
9670        :: serde :: Serialize,
9671        Clone,
9672        Copy,
9673        Debug,
9674        Eq,
9675        Hash,
9676        Ord,
9677        PartialEq,
9678        PartialOrd,
9679    )]
9680    pub enum OperationsAboutPrefer {
9681        #[serde(rename = "respond-async")]
9682        RespondAsync,
9683    }
9684
9685    impl ::std::convert::From<&Self> for OperationsAboutPrefer {
9686        fn from(value: &OperationsAboutPrefer) -> Self {
9687            value.clone()
9688        }
9689    }
9690
9691    impl ::std::fmt::Display for OperationsAboutPrefer {
9692        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9693            match *self {
9694                Self::RespondAsync => f.write_str("respond-async"),
9695            }
9696        }
9697    }
9698
9699    impl ::std::str::FromStr for OperationsAboutPrefer {
9700        type Err = self::error::ConversionError;
9701        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9702            match value {
9703                "respond-async" => Ok(Self::RespondAsync),
9704                _ => Err("invalid value".into()),
9705            }
9706        }
9707    }
9708
9709    impl ::std::convert::TryFrom<&str> for OperationsAboutPrefer {
9710        type Error = self::error::ConversionError;
9711        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9712            value.parse()
9713        }
9714    }
9715
9716    impl ::std::convert::TryFrom<&::std::string::String> for OperationsAboutPrefer {
9717        type Error = self::error::ConversionError;
9718        fn try_from(
9719            value: &::std::string::String,
9720        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9721            value.parse()
9722        }
9723    }
9724
9725    impl ::std::convert::TryFrom<::std::string::String> for OperationsAboutPrefer {
9726        type Error = self::error::ConversionError;
9727        fn try_from(
9728            value: ::std::string::String,
9729        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9730            value.parse()
9731        }
9732    }
9733
9734    ///`OperationsAboutRequest`
9735    ///
9736    /// <details><summary>JSON schema</summary>
9737    ///
9738    /// ```json
9739    ///{
9740    ///  "type": "object",
9741    ///  "properties": {
9742    ///    "_async": {
9743    ///      "description": "Run the command asynchronously. Returns a job id
9744    /// immediately.",
9745    ///      "type": "boolean"
9746    ///    },
9747    ///    "_group": {
9748    ///      "description": "Assign the request to a custom stats group.",
9749    ///      "type": "string"
9750    ///    },
9751    ///    "fs": {
9752    ///      "description": "Remote name or path to query for capacity
9753    /// information.",
9754    ///      "type": "string"
9755    ///    }
9756    ///  }
9757    ///}
9758    /// ```
9759    /// </details>
9760    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9761    pub struct OperationsAboutRequest {
9762        ///Run the command asynchronously. Returns a job id immediately.
9763        #[serde(
9764            rename = "_async",
9765            default,
9766            skip_serializing_if = "::std::option::Option::is_none"
9767        )]
9768        pub async_: ::std::option::Option<bool>,
9769        ///Remote name or path to query for capacity information.
9770        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9771        pub fs: ::std::option::Option<::std::string::String>,
9772        ///Assign the request to a custom stats group.
9773        #[serde(
9774            rename = "_group",
9775            default,
9776            skip_serializing_if = "::std::option::Option::is_none"
9777        )]
9778        pub group: ::std::option::Option<::std::string::String>,
9779    }
9780
9781    impl ::std::convert::From<&OperationsAboutRequest> for OperationsAboutRequest {
9782        fn from(value: &OperationsAboutRequest) -> Self {
9783            value.clone()
9784        }
9785    }
9786
9787    impl ::std::default::Default for OperationsAboutRequest {
9788        fn default() -> Self {
9789            Self {
9790                async_: Default::default(),
9791                fs: Default::default(),
9792                group: Default::default(),
9793            }
9794        }
9795    }
9796
9797    ///`OperationsAboutResponse`
9798    ///
9799    /// <details><summary>JSON schema</summary>
9800    ///
9801    /// ```json
9802    ///{
9803    ///  "type": "object",
9804    ///  "required": [
9805    ///    "free",
9806    ///    "total",
9807    ///    "used"
9808    ///  ],
9809    ///  "properties": {
9810    ///    "free": {
9811    ///      "type": "number"
9812    ///    },
9813    ///    "objects": {
9814    ///      "type": "number"
9815    ///    },
9816    ///    "other": {
9817    ///      "type": "number"
9818    ///    },
9819    ///    "total": {
9820    ///      "type": "number"
9821    ///    },
9822    ///    "trashed": {
9823    ///      "type": "number"
9824    ///    },
9825    ///    "used": {
9826    ///      "type": "number"
9827    ///    }
9828    ///  }
9829    ///}
9830    /// ```
9831    /// </details>
9832    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
9833    pub struct OperationsAboutResponse {
9834        pub free: f64,
9835        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9836        pub objects: ::std::option::Option<f64>,
9837        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9838        pub other: ::std::option::Option<f64>,
9839        pub total: f64,
9840        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
9841        pub trashed: ::std::option::Option<f64>,
9842        pub used: f64,
9843    }
9844
9845    impl ::std::convert::From<&OperationsAboutResponse> for OperationsAboutResponse {
9846        fn from(value: &OperationsAboutResponse) -> Self {
9847            value.clone()
9848        }
9849    }
9850
9851    ///`OperationsCheckPrefer`
9852    ///
9853    /// <details><summary>JSON schema</summary>
9854    ///
9855    /// ```json
9856    ///{
9857    ///  "type": "string",
9858    ///  "enum": [
9859    ///    "respond-async"
9860    ///  ]
9861    ///}
9862    /// ```
9863    /// </details>
9864    #[derive(
9865        :: serde :: Deserialize,
9866        :: serde :: Serialize,
9867        Clone,
9868        Copy,
9869        Debug,
9870        Eq,
9871        Hash,
9872        Ord,
9873        PartialEq,
9874        PartialOrd,
9875    )]
9876    pub enum OperationsCheckPrefer {
9877        #[serde(rename = "respond-async")]
9878        RespondAsync,
9879    }
9880
9881    impl ::std::convert::From<&Self> for OperationsCheckPrefer {
9882        fn from(value: &OperationsCheckPrefer) -> Self {
9883            value.clone()
9884        }
9885    }
9886
9887    impl ::std::fmt::Display for OperationsCheckPrefer {
9888        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9889            match *self {
9890                Self::RespondAsync => f.write_str("respond-async"),
9891            }
9892        }
9893    }
9894
9895    impl ::std::str::FromStr for OperationsCheckPrefer {
9896        type Err = self::error::ConversionError;
9897        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9898            match value {
9899                "respond-async" => Ok(Self::RespondAsync),
9900                _ => Err("invalid value".into()),
9901            }
9902        }
9903    }
9904
9905    impl ::std::convert::TryFrom<&str> for OperationsCheckPrefer {
9906        type Error = self::error::ConversionError;
9907        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
9908            value.parse()
9909        }
9910    }
9911
9912    impl ::std::convert::TryFrom<&::std::string::String> for OperationsCheckPrefer {
9913        type Error = self::error::ConversionError;
9914        fn try_from(
9915            value: &::std::string::String,
9916        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9917            value.parse()
9918        }
9919    }
9920
9921    impl ::std::convert::TryFrom<::std::string::String> for OperationsCheckPrefer {
9922        type Error = self::error::ConversionError;
9923        fn try_from(
9924            value: ::std::string::String,
9925        ) -> ::std::result::Result<Self, self::error::ConversionError> {
9926            value.parse()
9927        }
9928    }
9929
9930    ///`OperationsCheckRequest`
9931    ///
9932    /// <details><summary>JSON schema</summary>
9933    ///
9934    /// ```json
9935    ///{
9936    ///  "type": "object",
9937    ///  "properties": {
9938    ///    "_async": {
9939    ///      "description": "Run the command asynchronously. Returns a job id
9940    /// immediately.",
9941    ///      "type": "boolean"
9942    ///    },
9943    ///    "_group": {
9944    ///      "description": "Assign the request to a custom stats group.",
9945    ///      "type": "string"
9946    ///    },
9947    ///    "checkFileFs": {
9948    ///      "description": "Remote containing the checksum SUM file when using
9949    /// `checkFileHash`.",
9950    ///      "type": "string"
9951    ///    },
9952    ///    "checkFileHash": {
9953    ///      "description": "Hash name to expect in the supplied SUM file, such
9954    /// as `md5`.",
9955    ///      "type": "string"
9956    ///    },
9957    ///    "checkFileRemote": {
9958    ///      "description": "Path within `checkFileFs` to the checksum SUM
9959    /// file.",
9960    ///      "type": "string"
9961    ///    },
9962    ///    "combined": {
9963    ///      "description": "Set to true to include a combined summary report in
9964    /// the response.",
9965    ///      "type": "boolean"
9966    ///    },
9967    ///    "differ": {
9968    ///      "description": "Set to true to include differing files in the
9969    /// report.",
9970    ///      "type": "boolean"
9971    ///    },
9972    ///    "download": {
9973    ///      "description": "Set to true to read file contents during comparison
9974    /// instead of relying on hashes.",
9975    ///      "type": "boolean"
9976    ///    },
9977    ///    "dstFs": {
9978    ///      "description": "Destination remote name or path that should match
9979    /// the source.",
9980    ///      "type": "string"
9981    ///    },
9982    ///    "error": {
9983    ///      "description": "Set to true to include entries that encountered
9984    /// errors.",
9985    ///      "type": "boolean"
9986    ///    },
9987    ///    "match": {
9988    ///      "description": "Set to true to include matching files in the
9989    /// report.",
9990    ///      "type": "boolean"
9991    ///    },
9992    ///    "missingOnDst": {
9993    ///      "description": "Set to true to report files missing from the
9994    /// destination.",
9995    ///      "type": "boolean"
9996    ///    },
9997    ///    "missingOnSrc": {
9998    ///      "description": "Set to true to report files missing from the
9999    /// source.",
10000    ///      "type": "boolean"
10001    ///    },
10002    ///    "oneWay": {
10003    ///      "description": "Set to true to only ensure that source files exist
10004    /// on the destination.",
10005    ///      "type": "boolean"
10006    ///    },
10007    ///    "srcFs": {
10008    ///      "description": "Source remote name or path to verify, e.g.
10009    /// `drive:`.",
10010    ///      "type": "string"
10011    ///    }
10012    ///  }
10013    ///}
10014    /// ```
10015    /// </details>
10016    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10017    pub struct OperationsCheckRequest {
10018        ///Run the command asynchronously. Returns a job id immediately.
10019        #[serde(
10020            rename = "_async",
10021            default,
10022            skip_serializing_if = "::std::option::Option::is_none"
10023        )]
10024        pub async_: ::std::option::Option<bool>,
10025        ///Remote containing the checksum SUM file when using `checkFileHash`.
10026        #[serde(
10027            rename = "checkFileFs",
10028            default,
10029            skip_serializing_if = "::std::option::Option::is_none"
10030        )]
10031        pub check_file_fs: ::std::option::Option<::std::string::String>,
10032        ///Hash name to expect in the supplied SUM file, such as `md5`.
10033        #[serde(
10034            rename = "checkFileHash",
10035            default,
10036            skip_serializing_if = "::std::option::Option::is_none"
10037        )]
10038        pub check_file_hash: ::std::option::Option<::std::string::String>,
10039        ///Path within `checkFileFs` to the checksum SUM file.
10040        #[serde(
10041            rename = "checkFileRemote",
10042            default,
10043            skip_serializing_if = "::std::option::Option::is_none"
10044        )]
10045        pub check_file_remote: ::std::option::Option<::std::string::String>,
10046        ///Set to true to include a combined summary report in the response.
10047        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10048        pub combined: ::std::option::Option<bool>,
10049        ///Set to true to include differing files in the report.
10050        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10051        pub differ: ::std::option::Option<bool>,
10052        ///Set to true to read file contents during comparison instead of
10053        /// relying on hashes.
10054        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10055        pub download: ::std::option::Option<bool>,
10056        ///Destination remote name or path that should match the source.
10057        #[serde(
10058            rename = "dstFs",
10059            default,
10060            skip_serializing_if = "::std::option::Option::is_none"
10061        )]
10062        pub dst_fs: ::std::option::Option<::std::string::String>,
10063        ///Set to true to include entries that encountered errors.
10064        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10065        pub error: ::std::option::Option<bool>,
10066        ///Assign the request to a custom stats group.
10067        #[serde(
10068            rename = "_group",
10069            default,
10070            skip_serializing_if = "::std::option::Option::is_none"
10071        )]
10072        pub group: ::std::option::Option<::std::string::String>,
10073        ///Set to true to include matching files in the report.
10074        #[serde(
10075            rename = "match",
10076            default,
10077            skip_serializing_if = "::std::option::Option::is_none"
10078        )]
10079        pub match_: ::std::option::Option<bool>,
10080        ///Set to true to report files missing from the destination.
10081        #[serde(
10082            rename = "missingOnDst",
10083            default,
10084            skip_serializing_if = "::std::option::Option::is_none"
10085        )]
10086        pub missing_on_dst: ::std::option::Option<bool>,
10087        ///Set to true to report files missing from the source.
10088        #[serde(
10089            rename = "missingOnSrc",
10090            default,
10091            skip_serializing_if = "::std::option::Option::is_none"
10092        )]
10093        pub missing_on_src: ::std::option::Option<bool>,
10094        ///Set to true to only ensure that source files exist on the
10095        /// destination.
10096        #[serde(
10097            rename = "oneWay",
10098            default,
10099            skip_serializing_if = "::std::option::Option::is_none"
10100        )]
10101        pub one_way: ::std::option::Option<bool>,
10102        ///Source remote name or path to verify, e.g. `drive:`.
10103        #[serde(
10104            rename = "srcFs",
10105            default,
10106            skip_serializing_if = "::std::option::Option::is_none"
10107        )]
10108        pub src_fs: ::std::option::Option<::std::string::String>,
10109    }
10110
10111    impl ::std::convert::From<&OperationsCheckRequest> for OperationsCheckRequest {
10112        fn from(value: &OperationsCheckRequest) -> Self {
10113            value.clone()
10114        }
10115    }
10116
10117    impl ::std::default::Default for OperationsCheckRequest {
10118        fn default() -> Self {
10119            Self {
10120                async_: Default::default(),
10121                check_file_fs: Default::default(),
10122                check_file_hash: Default::default(),
10123                check_file_remote: Default::default(),
10124                combined: Default::default(),
10125                differ: Default::default(),
10126                download: Default::default(),
10127                dst_fs: Default::default(),
10128                error: Default::default(),
10129                group: Default::default(),
10130                match_: Default::default(),
10131                missing_on_dst: Default::default(),
10132                missing_on_src: Default::default(),
10133                one_way: Default::default(),
10134                src_fs: Default::default(),
10135            }
10136        }
10137    }
10138
10139    ///`OperationsCheckResponse`
10140    ///
10141    /// <details><summary>JSON schema</summary>
10142    ///
10143    /// ```json
10144    ///{
10145    ///  "type": "object",
10146    ///  "required": [
10147    ///    "status",
10148    ///    "success"
10149    ///  ],
10150    ///  "properties": {
10151    ///    "combined": {
10152    ///      "description": "Combined summary lines when `combined=true` is
10153    /// requested.",
10154    ///      "type": "array",
10155    ///      "items": {
10156    ///        "type": "string"
10157    ///      }
10158    ///    },
10159    ///    "differ": {
10160    ///      "description": "Files that differed between source and
10161    /// destination.",
10162    ///      "type": "array",
10163    ///      "items": {
10164    ///        "type": "string"
10165    ///      }
10166    ///    },
10167    ///    "error": {
10168    ///      "description": "Entries that produced errors during the check.",
10169    ///      "type": "array",
10170    ///      "items": {
10171    ///        "type": "string"
10172    ///      }
10173    ///    },
10174    ///    "hashType": {
10175    ///      "description": "Hash algorithm used for comparisons when
10176    /// applicable.",
10177    ///      "type": "string"
10178    ///    },
10179    ///    "match": {
10180    ///      "description": "Files that matched on both sides.",
10181    ///      "type": "array",
10182    ///      "items": {
10183    ///        "type": "string"
10184    ///      }
10185    ///    },
10186    ///    "missingOnDst": {
10187    ///      "description": "Files present on the source but missing from the
10188    /// destination.",
10189    ///      "type": "array",
10190    ///      "items": {
10191    ///        "type": "string"
10192    ///      }
10193    ///    },
10194    ///    "missingOnSrc": {
10195    ///      "description": "Files present on the destination but missing from
10196    /// the source.",
10197    ///      "type": "array",
10198    ///      "items": {
10199    ///        "type": "string"
10200    ///      }
10201    ///    },
10202    ///    "status": {
10203    ///      "description": "Human readable status string.",
10204    ///      "type": "string"
10205    ///    },
10206    ///    "success": {
10207    ///      "description": "True when the check completes without differences
10208    /// or errors.",
10209    ///      "type": "boolean"
10210    ///    }
10211    ///  }
10212    ///}
10213    /// ```
10214    /// </details>
10215    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10216    pub struct OperationsCheckResponse {
10217        ///Combined summary lines when `combined=true` is requested.
10218        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
10219        pub combined: ::std::vec::Vec<::std::string::String>,
10220        ///Files that differed between source and destination.
10221        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
10222        pub differ: ::std::vec::Vec<::std::string::String>,
10223        ///Entries that produced errors during the check.
10224        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
10225        pub error: ::std::vec::Vec<::std::string::String>,
10226        ///Hash algorithm used for comparisons when applicable.
10227        #[serde(
10228            rename = "hashType",
10229            default,
10230            skip_serializing_if = "::std::option::Option::is_none"
10231        )]
10232        pub hash_type: ::std::option::Option<::std::string::String>,
10233        ///Files that matched on both sides.
10234        #[serde(
10235            rename = "match",
10236            default,
10237            skip_serializing_if = "::std::vec::Vec::is_empty"
10238        )]
10239        pub match_: ::std::vec::Vec<::std::string::String>,
10240        ///Files present on the source but missing from the destination.
10241        #[serde(
10242            rename = "missingOnDst",
10243            default,
10244            skip_serializing_if = "::std::vec::Vec::is_empty"
10245        )]
10246        pub missing_on_dst: ::std::vec::Vec<::std::string::String>,
10247        ///Files present on the destination but missing from the source.
10248        #[serde(
10249            rename = "missingOnSrc",
10250            default,
10251            skip_serializing_if = "::std::vec::Vec::is_empty"
10252        )]
10253        pub missing_on_src: ::std::vec::Vec<::std::string::String>,
10254        ///Human readable status string.
10255        pub status: ::std::string::String,
10256        ///True when the check completes without differences or errors.
10257        pub success: bool,
10258    }
10259
10260    impl ::std::convert::From<&OperationsCheckResponse> for OperationsCheckResponse {
10261        fn from(value: &OperationsCheckResponse) -> Self {
10262            value.clone()
10263        }
10264    }
10265
10266    ///`OperationsCleanupPrefer`
10267    ///
10268    /// <details><summary>JSON schema</summary>
10269    ///
10270    /// ```json
10271    ///{
10272    ///  "type": "string",
10273    ///  "enum": [
10274    ///    "respond-async"
10275    ///  ]
10276    ///}
10277    /// ```
10278    /// </details>
10279    #[derive(
10280        :: serde :: Deserialize,
10281        :: serde :: Serialize,
10282        Clone,
10283        Copy,
10284        Debug,
10285        Eq,
10286        Hash,
10287        Ord,
10288        PartialEq,
10289        PartialOrd,
10290    )]
10291    pub enum OperationsCleanupPrefer {
10292        #[serde(rename = "respond-async")]
10293        RespondAsync,
10294    }
10295
10296    impl ::std::convert::From<&Self> for OperationsCleanupPrefer {
10297        fn from(value: &OperationsCleanupPrefer) -> Self {
10298            value.clone()
10299        }
10300    }
10301
10302    impl ::std::fmt::Display for OperationsCleanupPrefer {
10303        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10304            match *self {
10305                Self::RespondAsync => f.write_str("respond-async"),
10306            }
10307        }
10308    }
10309
10310    impl ::std::str::FromStr for OperationsCleanupPrefer {
10311        type Err = self::error::ConversionError;
10312        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10313            match value {
10314                "respond-async" => Ok(Self::RespondAsync),
10315                _ => Err("invalid value".into()),
10316            }
10317        }
10318    }
10319
10320    impl ::std::convert::TryFrom<&str> for OperationsCleanupPrefer {
10321        type Error = self::error::ConversionError;
10322        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10323            value.parse()
10324        }
10325    }
10326
10327    impl ::std::convert::TryFrom<&::std::string::String> for OperationsCleanupPrefer {
10328        type Error = self::error::ConversionError;
10329        fn try_from(
10330            value: &::std::string::String,
10331        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10332            value.parse()
10333        }
10334    }
10335
10336    impl ::std::convert::TryFrom<::std::string::String> for OperationsCleanupPrefer {
10337        type Error = self::error::ConversionError;
10338        fn try_from(
10339            value: ::std::string::String,
10340        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10341            value.parse()
10342        }
10343    }
10344
10345    ///`OperationsCleanupRequest`
10346    ///
10347    /// <details><summary>JSON schema</summary>
10348    ///
10349    /// ```json
10350    ///{
10351    ///  "type": "object",
10352    ///  "properties": {
10353    ///    "_async": {
10354    ///      "description": "Run the command asynchronously. Returns a job id
10355    /// immediately.",
10356    ///      "type": "boolean"
10357    ///    },
10358    ///    "_group": {
10359    ///      "description": "Assign the request to a custom stats group.",
10360    ///      "type": "string"
10361    ///    },
10362    ///    "fs": {
10363    ///      "description": "Remote name or path to clean up, for example
10364    /// `drive:`.",
10365    ///      "type": "string"
10366    ///    }
10367    ///  }
10368    ///}
10369    /// ```
10370    /// </details>
10371    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10372    pub struct OperationsCleanupRequest {
10373        ///Run the command asynchronously. Returns a job id immediately.
10374        #[serde(
10375            rename = "_async",
10376            default,
10377            skip_serializing_if = "::std::option::Option::is_none"
10378        )]
10379        pub async_: ::std::option::Option<bool>,
10380        ///Remote name or path to clean up, for example `drive:`.
10381        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10382        pub fs: ::std::option::Option<::std::string::String>,
10383        ///Assign the request to a custom stats group.
10384        #[serde(
10385            rename = "_group",
10386            default,
10387            skip_serializing_if = "::std::option::Option::is_none"
10388        )]
10389        pub group: ::std::option::Option<::std::string::String>,
10390    }
10391
10392    impl ::std::convert::From<&OperationsCleanupRequest> for OperationsCleanupRequest {
10393        fn from(value: &OperationsCleanupRequest) -> Self {
10394            value.clone()
10395        }
10396    }
10397
10398    impl ::std::default::Default for OperationsCleanupRequest {
10399        fn default() -> Self {
10400            Self {
10401                async_: Default::default(),
10402                fs: Default::default(),
10403                group: Default::default(),
10404            }
10405        }
10406    }
10407
10408    ///`OperationsCopyfilePrefer`
10409    ///
10410    /// <details><summary>JSON schema</summary>
10411    ///
10412    /// ```json
10413    ///{
10414    ///  "type": "string",
10415    ///  "enum": [
10416    ///    "respond-async"
10417    ///  ]
10418    ///}
10419    /// ```
10420    /// </details>
10421    #[derive(
10422        :: serde :: Deserialize,
10423        :: serde :: Serialize,
10424        Clone,
10425        Copy,
10426        Debug,
10427        Eq,
10428        Hash,
10429        Ord,
10430        PartialEq,
10431        PartialOrd,
10432    )]
10433    pub enum OperationsCopyfilePrefer {
10434        #[serde(rename = "respond-async")]
10435        RespondAsync,
10436    }
10437
10438    impl ::std::convert::From<&Self> for OperationsCopyfilePrefer {
10439        fn from(value: &OperationsCopyfilePrefer) -> Self {
10440            value.clone()
10441        }
10442    }
10443
10444    impl ::std::fmt::Display for OperationsCopyfilePrefer {
10445        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10446            match *self {
10447                Self::RespondAsync => f.write_str("respond-async"),
10448            }
10449        }
10450    }
10451
10452    impl ::std::str::FromStr for OperationsCopyfilePrefer {
10453        type Err = self::error::ConversionError;
10454        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10455            match value {
10456                "respond-async" => Ok(Self::RespondAsync),
10457                _ => Err("invalid value".into()),
10458            }
10459        }
10460    }
10461
10462    impl ::std::convert::TryFrom<&str> for OperationsCopyfilePrefer {
10463        type Error = self::error::ConversionError;
10464        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10465            value.parse()
10466        }
10467    }
10468
10469    impl ::std::convert::TryFrom<&::std::string::String> for OperationsCopyfilePrefer {
10470        type Error = self::error::ConversionError;
10471        fn try_from(
10472            value: &::std::string::String,
10473        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10474            value.parse()
10475        }
10476    }
10477
10478    impl ::std::convert::TryFrom<::std::string::String> for OperationsCopyfilePrefer {
10479        type Error = self::error::ConversionError;
10480        fn try_from(
10481            value: ::std::string::String,
10482        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10483            value.parse()
10484        }
10485    }
10486
10487    ///`OperationsCopyfileRequest`
10488    ///
10489    /// <details><summary>JSON schema</summary>
10490    ///
10491    /// ```json
10492    ///{
10493    ///  "type": "object",
10494    ///  "properties": {
10495    ///    "_async": {
10496    ///      "description": "Run the command asynchronously. Returns a job id
10497    /// immediately.",
10498    ///      "type": "boolean"
10499    ///    },
10500    ///    "_group": {
10501    ///      "description": "Assign the request to a custom stats group.",
10502    ///      "type": "string"
10503    ///    },
10504    ///    "dstFs": {
10505    ///      "description": "Destination remote name or path, such as `drive2:`
10506    /// or `/` for local filesystem.",
10507    ///      "type": "string"
10508    ///    },
10509    ///    "dstRemote": {
10510    ///      "description": "Target path within `dstFs` where the file should be
10511    /// written.",
10512    ///      "type": "string"
10513    ///    },
10514    ///    "srcFs": {
10515    ///      "description": "Source remote name or path, such as `drive:` or `/`
10516    /// for the local filesystem.",
10517    ///      "type": "string"
10518    ///    },
10519    ///    "srcRemote": {
10520    ///      "description": "Path to the source object within `srcFs`, for
10521    /// example `dir/file.txt`.",
10522    ///      "type": "string"
10523    ///    }
10524    ///  }
10525    ///}
10526    /// ```
10527    /// </details>
10528    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10529    pub struct OperationsCopyfileRequest {
10530        ///Run the command asynchronously. Returns a job id immediately.
10531        #[serde(
10532            rename = "_async",
10533            default,
10534            skip_serializing_if = "::std::option::Option::is_none"
10535        )]
10536        pub async_: ::std::option::Option<bool>,
10537        ///Destination remote name or path, such as `drive2:` or `/` for local
10538        /// filesystem.
10539        #[serde(
10540            rename = "dstFs",
10541            default,
10542            skip_serializing_if = "::std::option::Option::is_none"
10543        )]
10544        pub dst_fs: ::std::option::Option<::std::string::String>,
10545        ///Target path within `dstFs` where the file should be written.
10546        #[serde(
10547            rename = "dstRemote",
10548            default,
10549            skip_serializing_if = "::std::option::Option::is_none"
10550        )]
10551        pub dst_remote: ::std::option::Option<::std::string::String>,
10552        ///Assign the request to a custom stats group.
10553        #[serde(
10554            rename = "_group",
10555            default,
10556            skip_serializing_if = "::std::option::Option::is_none"
10557        )]
10558        pub group: ::std::option::Option<::std::string::String>,
10559        ///Source remote name or path, such as `drive:` or `/` for the local
10560        /// filesystem.
10561        #[serde(
10562            rename = "srcFs",
10563            default,
10564            skip_serializing_if = "::std::option::Option::is_none"
10565        )]
10566        pub src_fs: ::std::option::Option<::std::string::String>,
10567        ///Path to the source object within `srcFs`, for example
10568        /// `dir/file.txt`.
10569        #[serde(
10570            rename = "srcRemote",
10571            default,
10572            skip_serializing_if = "::std::option::Option::is_none"
10573        )]
10574        pub src_remote: ::std::option::Option<::std::string::String>,
10575    }
10576
10577    impl ::std::convert::From<&OperationsCopyfileRequest> for OperationsCopyfileRequest {
10578        fn from(value: &OperationsCopyfileRequest) -> Self {
10579            value.clone()
10580        }
10581    }
10582
10583    impl ::std::default::Default for OperationsCopyfileRequest {
10584        fn default() -> Self {
10585            Self {
10586                async_: Default::default(),
10587                dst_fs: Default::default(),
10588                dst_remote: Default::default(),
10589                group: Default::default(),
10590                src_fs: Default::default(),
10591                src_remote: Default::default(),
10592            }
10593        }
10594    }
10595
10596    ///`OperationsCopyurlPrefer`
10597    ///
10598    /// <details><summary>JSON schema</summary>
10599    ///
10600    /// ```json
10601    ///{
10602    ///  "type": "string",
10603    ///  "enum": [
10604    ///    "respond-async"
10605    ///  ]
10606    ///}
10607    /// ```
10608    /// </details>
10609    #[derive(
10610        :: serde :: Deserialize,
10611        :: serde :: Serialize,
10612        Clone,
10613        Copy,
10614        Debug,
10615        Eq,
10616        Hash,
10617        Ord,
10618        PartialEq,
10619        PartialOrd,
10620    )]
10621    pub enum OperationsCopyurlPrefer {
10622        #[serde(rename = "respond-async")]
10623        RespondAsync,
10624    }
10625
10626    impl ::std::convert::From<&Self> for OperationsCopyurlPrefer {
10627        fn from(value: &OperationsCopyurlPrefer) -> Self {
10628            value.clone()
10629        }
10630    }
10631
10632    impl ::std::fmt::Display for OperationsCopyurlPrefer {
10633        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10634            match *self {
10635                Self::RespondAsync => f.write_str("respond-async"),
10636            }
10637        }
10638    }
10639
10640    impl ::std::str::FromStr for OperationsCopyurlPrefer {
10641        type Err = self::error::ConversionError;
10642        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10643            match value {
10644                "respond-async" => Ok(Self::RespondAsync),
10645                _ => Err("invalid value".into()),
10646            }
10647        }
10648    }
10649
10650    impl ::std::convert::TryFrom<&str> for OperationsCopyurlPrefer {
10651        type Error = self::error::ConversionError;
10652        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10653            value.parse()
10654        }
10655    }
10656
10657    impl ::std::convert::TryFrom<&::std::string::String> for OperationsCopyurlPrefer {
10658        type Error = self::error::ConversionError;
10659        fn try_from(
10660            value: &::std::string::String,
10661        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10662            value.parse()
10663        }
10664    }
10665
10666    impl ::std::convert::TryFrom<::std::string::String> for OperationsCopyurlPrefer {
10667        type Error = self::error::ConversionError;
10668        fn try_from(
10669            value: ::std::string::String,
10670        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10671            value.parse()
10672        }
10673    }
10674
10675    ///`OperationsCopyurlRequest`
10676    ///
10677    /// <details><summary>JSON schema</summary>
10678    ///
10679    /// ```json
10680    ///{
10681    ///  "type": "object",
10682    ///  "properties": {
10683    ///    "_async": {
10684    ///      "description": "Run the command asynchronously. Returns a job id
10685    /// immediately.",
10686    ///      "type": "boolean"
10687    ///    },
10688    ///    "_group": {
10689    ///      "description": "Assign the request to a custom stats group.",
10690    ///      "type": "string"
10691    ///    },
10692    ///    "autoFilename": {
10693    ///      "description": "Set to true to derive the destination filename from
10694    /// the URL.",
10695    ///      "type": "boolean"
10696    ///    },
10697    ///    "fs": {
10698    ///      "description": "Remote name or path that will receive the
10699    /// downloaded file, e.g. `drive:`.",
10700    ///      "type": "string"
10701    ///    },
10702    ///    "remote": {
10703    ///      "description": "Destination path within `fs` where the fetched
10704    /// object will be stored.",
10705    ///      "type": "string"
10706    ///    },
10707    ///    "url": {
10708    ///      "description": "Source URL to fetch the object from.",
10709    ///      "type": "string"
10710    ///    }
10711    ///  }
10712    ///}
10713    /// ```
10714    /// </details>
10715    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10716    pub struct OperationsCopyurlRequest {
10717        ///Run the command asynchronously. Returns a job id immediately.
10718        #[serde(
10719            rename = "_async",
10720            default,
10721            skip_serializing_if = "::std::option::Option::is_none"
10722        )]
10723        pub async_: ::std::option::Option<bool>,
10724        ///Set to true to derive the destination filename from the URL.
10725        #[serde(
10726            rename = "autoFilename",
10727            default,
10728            skip_serializing_if = "::std::option::Option::is_none"
10729        )]
10730        pub auto_filename: ::std::option::Option<bool>,
10731        ///Remote name or path that will receive the downloaded file, e.g.
10732        /// `drive:`.
10733        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10734        pub fs: ::std::option::Option<::std::string::String>,
10735        ///Assign the request to a custom stats group.
10736        #[serde(
10737            rename = "_group",
10738            default,
10739            skip_serializing_if = "::std::option::Option::is_none"
10740        )]
10741        pub group: ::std::option::Option<::std::string::String>,
10742        ///Destination path within `fs` where the fetched object will be
10743        /// stored.
10744        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10745        pub remote: ::std::option::Option<::std::string::String>,
10746        ///Source URL to fetch the object from.
10747        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10748        pub url: ::std::option::Option<::std::string::String>,
10749    }
10750
10751    impl ::std::convert::From<&OperationsCopyurlRequest> for OperationsCopyurlRequest {
10752        fn from(value: &OperationsCopyurlRequest) -> Self {
10753            value.clone()
10754        }
10755    }
10756
10757    impl ::std::default::Default for OperationsCopyurlRequest {
10758        fn default() -> Self {
10759            Self {
10760                async_: Default::default(),
10761                auto_filename: Default::default(),
10762                fs: Default::default(),
10763                group: Default::default(),
10764                remote: Default::default(),
10765                url: Default::default(),
10766            }
10767        }
10768    }
10769
10770    ///`OperationsDeletePrefer`
10771    ///
10772    /// <details><summary>JSON schema</summary>
10773    ///
10774    /// ```json
10775    ///{
10776    ///  "type": "string",
10777    ///  "enum": [
10778    ///    "respond-async"
10779    ///  ]
10780    ///}
10781    /// ```
10782    /// </details>
10783    #[derive(
10784        :: serde :: Deserialize,
10785        :: serde :: Serialize,
10786        Clone,
10787        Copy,
10788        Debug,
10789        Eq,
10790        Hash,
10791        Ord,
10792        PartialEq,
10793        PartialOrd,
10794    )]
10795    pub enum OperationsDeletePrefer {
10796        #[serde(rename = "respond-async")]
10797        RespondAsync,
10798    }
10799
10800    impl ::std::convert::From<&Self> for OperationsDeletePrefer {
10801        fn from(value: &OperationsDeletePrefer) -> Self {
10802            value.clone()
10803        }
10804    }
10805
10806    impl ::std::fmt::Display for OperationsDeletePrefer {
10807        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10808            match *self {
10809                Self::RespondAsync => f.write_str("respond-async"),
10810            }
10811        }
10812    }
10813
10814    impl ::std::str::FromStr for OperationsDeletePrefer {
10815        type Err = self::error::ConversionError;
10816        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10817            match value {
10818                "respond-async" => Ok(Self::RespondAsync),
10819                _ => Err("invalid value".into()),
10820            }
10821        }
10822    }
10823
10824    impl ::std::convert::TryFrom<&str> for OperationsDeletePrefer {
10825        type Error = self::error::ConversionError;
10826        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10827            value.parse()
10828        }
10829    }
10830
10831    impl ::std::convert::TryFrom<&::std::string::String> for OperationsDeletePrefer {
10832        type Error = self::error::ConversionError;
10833        fn try_from(
10834            value: &::std::string::String,
10835        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10836            value.parse()
10837        }
10838    }
10839
10840    impl ::std::convert::TryFrom<::std::string::String> for OperationsDeletePrefer {
10841        type Error = self::error::ConversionError;
10842        fn try_from(
10843            value: ::std::string::String,
10844        ) -> ::std::result::Result<Self, self::error::ConversionError> {
10845            value.parse()
10846        }
10847    }
10848
10849    ///`OperationsDeleteRequest`
10850    ///
10851    /// <details><summary>JSON schema</summary>
10852    ///
10853    /// ```json
10854    ///{
10855    ///  "type": "object",
10856    ///  "properties": {
10857    ///    "_async": {
10858    ///      "description": "Run the command asynchronously. Returns a job id
10859    /// immediately.",
10860    ///      "type": "boolean"
10861    ///    },
10862    ///    "_config": {
10863    ///      "description": "JSON encoded config overrides applied for this call
10864    /// only.",
10865    ///      "type": "string"
10866    ///    },
10867    ///    "_filter": {
10868    ///      "description": "JSON encoded filter overrides applied for this call
10869    /// only.",
10870    ///      "type": "string"
10871    ///    },
10872    ///    "_group": {
10873    ///      "description": "Assign the request to a custom stats group.",
10874    ///      "type": "string"
10875    ///    },
10876    ///    "fs": {
10877    ///      "description": "Remote name or path whose contents should be
10878    /// removed.",
10879    ///      "type": "string"
10880    ///    }
10881    ///  }
10882    ///}
10883    /// ```
10884    /// </details>
10885    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
10886    pub struct OperationsDeleteRequest {
10887        ///Run the command asynchronously. Returns a job id immediately.
10888        #[serde(
10889            rename = "_async",
10890            default,
10891            skip_serializing_if = "::std::option::Option::is_none"
10892        )]
10893        pub async_: ::std::option::Option<bool>,
10894        ///JSON encoded config overrides applied for this call only.
10895        #[serde(
10896            rename = "_config",
10897            default,
10898            skip_serializing_if = "::std::option::Option::is_none"
10899        )]
10900        pub config: ::std::option::Option<::std::string::String>,
10901        ///JSON encoded filter overrides applied for this call only.
10902        #[serde(
10903            rename = "_filter",
10904            default,
10905            skip_serializing_if = "::std::option::Option::is_none"
10906        )]
10907        pub filter: ::std::option::Option<::std::string::String>,
10908        ///Remote name or path whose contents should be removed.
10909        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
10910        pub fs: ::std::option::Option<::std::string::String>,
10911        ///Assign the request to a custom stats group.
10912        #[serde(
10913            rename = "_group",
10914            default,
10915            skip_serializing_if = "::std::option::Option::is_none"
10916        )]
10917        pub group: ::std::option::Option<::std::string::String>,
10918    }
10919
10920    impl ::std::convert::From<&OperationsDeleteRequest> for OperationsDeleteRequest {
10921        fn from(value: &OperationsDeleteRequest) -> Self {
10922            value.clone()
10923        }
10924    }
10925
10926    impl ::std::default::Default for OperationsDeleteRequest {
10927        fn default() -> Self {
10928            Self {
10929                async_: Default::default(),
10930                config: Default::default(),
10931                filter: Default::default(),
10932                fs: Default::default(),
10933                group: Default::default(),
10934            }
10935        }
10936    }
10937
10938    ///`OperationsDeletefilePrefer`
10939    ///
10940    /// <details><summary>JSON schema</summary>
10941    ///
10942    /// ```json
10943    ///{
10944    ///  "type": "string",
10945    ///  "enum": [
10946    ///    "respond-async"
10947    ///  ]
10948    ///}
10949    /// ```
10950    /// </details>
10951    #[derive(
10952        :: serde :: Deserialize,
10953        :: serde :: Serialize,
10954        Clone,
10955        Copy,
10956        Debug,
10957        Eq,
10958        Hash,
10959        Ord,
10960        PartialEq,
10961        PartialOrd,
10962    )]
10963    pub enum OperationsDeletefilePrefer {
10964        #[serde(rename = "respond-async")]
10965        RespondAsync,
10966    }
10967
10968    impl ::std::convert::From<&Self> for OperationsDeletefilePrefer {
10969        fn from(value: &OperationsDeletefilePrefer) -> Self {
10970            value.clone()
10971        }
10972    }
10973
10974    impl ::std::fmt::Display for OperationsDeletefilePrefer {
10975        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10976            match *self {
10977                Self::RespondAsync => f.write_str("respond-async"),
10978            }
10979        }
10980    }
10981
10982    impl ::std::str::FromStr for OperationsDeletefilePrefer {
10983        type Err = self::error::ConversionError;
10984        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10985            match value {
10986                "respond-async" => Ok(Self::RespondAsync),
10987                _ => Err("invalid value".into()),
10988            }
10989        }
10990    }
10991
10992    impl ::std::convert::TryFrom<&str> for OperationsDeletefilePrefer {
10993        type Error = self::error::ConversionError;
10994        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
10995            value.parse()
10996        }
10997    }
10998
10999    impl ::std::convert::TryFrom<&::std::string::String> for OperationsDeletefilePrefer {
11000        type Error = self::error::ConversionError;
11001        fn try_from(
11002            value: &::std::string::String,
11003        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11004            value.parse()
11005        }
11006    }
11007
11008    impl ::std::convert::TryFrom<::std::string::String> for OperationsDeletefilePrefer {
11009        type Error = self::error::ConversionError;
11010        fn try_from(
11011            value: ::std::string::String,
11012        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11013            value.parse()
11014        }
11015    }
11016
11017    ///`OperationsDeletefileRequest`
11018    ///
11019    /// <details><summary>JSON schema</summary>
11020    ///
11021    /// ```json
11022    ///{
11023    ///  "type": "object",
11024    ///  "properties": {
11025    ///    "_async": {
11026    ///      "description": "Run the command asynchronously. Returns a job id
11027    /// immediately.",
11028    ///      "type": "boolean"
11029    ///    },
11030    ///    "_group": {
11031    ///      "description": "Assign the request to a custom stats group.",
11032    ///      "type": "string"
11033    ///    },
11034    ///    "fs": {
11035    ///      "description": "Remote name or path that contains the file to
11036    /// delete.",
11037    ///      "type": "string"
11038    ///    },
11039    ///    "remote": {
11040    ///      "description": "Exact path to the file within `fs` that should be
11041    /// deleted.",
11042    ///      "type": "string"
11043    ///    }
11044    ///  }
11045    ///}
11046    /// ```
11047    /// </details>
11048    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11049    pub struct OperationsDeletefileRequest {
11050        ///Run the command asynchronously. Returns a job id immediately.
11051        #[serde(
11052            rename = "_async",
11053            default,
11054            skip_serializing_if = "::std::option::Option::is_none"
11055        )]
11056        pub async_: ::std::option::Option<bool>,
11057        ///Remote name or path that contains the file to delete.
11058        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11059        pub fs: ::std::option::Option<::std::string::String>,
11060        ///Assign the request to a custom stats group.
11061        #[serde(
11062            rename = "_group",
11063            default,
11064            skip_serializing_if = "::std::option::Option::is_none"
11065        )]
11066        pub group: ::std::option::Option<::std::string::String>,
11067        ///Exact path to the file within `fs` that should be deleted.
11068        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11069        pub remote: ::std::option::Option<::std::string::String>,
11070    }
11071
11072    impl ::std::convert::From<&OperationsDeletefileRequest> for OperationsDeletefileRequest {
11073        fn from(value: &OperationsDeletefileRequest) -> Self {
11074            value.clone()
11075        }
11076    }
11077
11078    impl ::std::default::Default for OperationsDeletefileRequest {
11079        fn default() -> Self {
11080            Self {
11081                async_: Default::default(),
11082                fs: Default::default(),
11083                group: Default::default(),
11084                remote: Default::default(),
11085            }
11086        }
11087    }
11088
11089    ///`OperationsFsinfoPrefer`
11090    ///
11091    /// <details><summary>JSON schema</summary>
11092    ///
11093    /// ```json
11094    ///{
11095    ///  "type": "string",
11096    ///  "enum": [
11097    ///    "respond-async"
11098    ///  ]
11099    ///}
11100    /// ```
11101    /// </details>
11102    #[derive(
11103        :: serde :: Deserialize,
11104        :: serde :: Serialize,
11105        Clone,
11106        Copy,
11107        Debug,
11108        Eq,
11109        Hash,
11110        Ord,
11111        PartialEq,
11112        PartialOrd,
11113    )]
11114    pub enum OperationsFsinfoPrefer {
11115        #[serde(rename = "respond-async")]
11116        RespondAsync,
11117    }
11118
11119    impl ::std::convert::From<&Self> for OperationsFsinfoPrefer {
11120        fn from(value: &OperationsFsinfoPrefer) -> Self {
11121            value.clone()
11122        }
11123    }
11124
11125    impl ::std::fmt::Display for OperationsFsinfoPrefer {
11126        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11127            match *self {
11128                Self::RespondAsync => f.write_str("respond-async"),
11129            }
11130        }
11131    }
11132
11133    impl ::std::str::FromStr for OperationsFsinfoPrefer {
11134        type Err = self::error::ConversionError;
11135        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11136            match value {
11137                "respond-async" => Ok(Self::RespondAsync),
11138                _ => Err("invalid value".into()),
11139            }
11140        }
11141    }
11142
11143    impl ::std::convert::TryFrom<&str> for OperationsFsinfoPrefer {
11144        type Error = self::error::ConversionError;
11145        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11146            value.parse()
11147        }
11148    }
11149
11150    impl ::std::convert::TryFrom<&::std::string::String> for OperationsFsinfoPrefer {
11151        type Error = self::error::ConversionError;
11152        fn try_from(
11153            value: &::std::string::String,
11154        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11155            value.parse()
11156        }
11157    }
11158
11159    impl ::std::convert::TryFrom<::std::string::String> for OperationsFsinfoPrefer {
11160        type Error = self::error::ConversionError;
11161        fn try_from(
11162            value: ::std::string::String,
11163        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11164            value.parse()
11165        }
11166    }
11167
11168    ///`OperationsFsinfoRequest`
11169    ///
11170    /// <details><summary>JSON schema</summary>
11171    ///
11172    /// ```json
11173    ///{
11174    ///  "type": "object",
11175    ///  "properties": {
11176    ///    "_async": {
11177    ///      "description": "Run the command asynchronously. Returns a job id
11178    /// immediately.",
11179    ///      "type": "boolean"
11180    ///    },
11181    ///    "_group": {
11182    ///      "description": "Assign the request to a custom stats group.",
11183    ///      "type": "string"
11184    ///    },
11185    ///    "fs": {
11186    ///      "description": "Remote name or path to inspect, e.g. `drive:`.",
11187    ///      "type": "string"
11188    ///    }
11189    ///  }
11190    ///}
11191    /// ```
11192    /// </details>
11193    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11194    pub struct OperationsFsinfoRequest {
11195        ///Run the command asynchronously. Returns a job id immediately.
11196        #[serde(
11197            rename = "_async",
11198            default,
11199            skip_serializing_if = "::std::option::Option::is_none"
11200        )]
11201        pub async_: ::std::option::Option<bool>,
11202        ///Remote name or path to inspect, e.g. `drive:`.
11203        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11204        pub fs: ::std::option::Option<::std::string::String>,
11205        ///Assign the request to a custom stats group.
11206        #[serde(
11207            rename = "_group",
11208            default,
11209            skip_serializing_if = "::std::option::Option::is_none"
11210        )]
11211        pub group: ::std::option::Option<::std::string::String>,
11212    }
11213
11214    impl ::std::convert::From<&OperationsFsinfoRequest> for OperationsFsinfoRequest {
11215        fn from(value: &OperationsFsinfoRequest) -> Self {
11216            value.clone()
11217        }
11218    }
11219
11220    impl ::std::default::Default for OperationsFsinfoRequest {
11221        fn default() -> Self {
11222            Self {
11223                async_: Default::default(),
11224                fs: Default::default(),
11225                group: Default::default(),
11226            }
11227        }
11228    }
11229
11230    ///`OperationsFsinfoResponse`
11231    ///
11232    /// <details><summary>JSON schema</summary>
11233    ///
11234    /// ```json
11235    ///{
11236    ///  "type": "object",
11237    ///  "required": [
11238    ///    "Features",
11239    ///    "Hashes",
11240    ///    "Name",
11241    ///    "Precision",
11242    ///    "Root",
11243    ///    "String"
11244    ///  ],
11245    ///  "properties": {
11246    ///    "Features": {
11247    ///      "type": "object",
11248    ///      "additionalProperties": {
11249    ///        "type": "boolean"
11250    ///      }
11251    ///    },
11252    ///    "Hashes": {
11253    ///      "type": "array",
11254    ///      "items": {
11255    ///        "type": "string"
11256    ///      }
11257    ///    },
11258    ///    "MetadataInfo": {
11259    ///      "type": [
11260    ///        "object",
11261    ///        "null"
11262    ///      ],
11263    ///      "additionalProperties": true
11264    ///    },
11265    ///    "Name": {
11266    ///      "type": "string"
11267    ///    },
11268    ///    "Precision": {
11269    ///      "type": "number"
11270    ///    },
11271    ///    "Root": {
11272    ///      "type": "string"
11273    ///    },
11274    ///    "String": {
11275    ///      "type": "string"
11276    ///    }
11277    ///  }
11278    ///}
11279    /// ```
11280    /// </details>
11281    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11282    pub struct OperationsFsinfoResponse {
11283        #[serde(rename = "Features")]
11284        pub features: ::std::collections::HashMap<::std::string::String, bool>,
11285        #[serde(rename = "Hashes")]
11286        pub hashes: ::std::vec::Vec<::std::string::String>,
11287        #[serde(
11288            rename = "MetadataInfo",
11289            default,
11290            skip_serializing_if = "::std::option::Option::is_none"
11291        )]
11292        pub metadata_info:
11293            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11294        #[serde(rename = "Name")]
11295        pub name: ::std::string::String,
11296        #[serde(rename = "Precision")]
11297        pub precision: f64,
11298        #[serde(rename = "Root")]
11299        pub root: ::std::string::String,
11300        #[serde(rename = "String")]
11301        pub string: ::std::string::String,
11302    }
11303
11304    impl ::std::convert::From<&OperationsFsinfoResponse> for OperationsFsinfoResponse {
11305        fn from(value: &OperationsFsinfoResponse) -> Self {
11306            value.clone()
11307        }
11308    }
11309
11310    ///`OperationsHashsumPrefer`
11311    ///
11312    /// <details><summary>JSON schema</summary>
11313    ///
11314    /// ```json
11315    ///{
11316    ///  "type": "string",
11317    ///  "enum": [
11318    ///    "respond-async"
11319    ///  ]
11320    ///}
11321    /// ```
11322    /// </details>
11323    #[derive(
11324        :: serde :: Deserialize,
11325        :: serde :: Serialize,
11326        Clone,
11327        Copy,
11328        Debug,
11329        Eq,
11330        Hash,
11331        Ord,
11332        PartialEq,
11333        PartialOrd,
11334    )]
11335    pub enum OperationsHashsumPrefer {
11336        #[serde(rename = "respond-async")]
11337        RespondAsync,
11338    }
11339
11340    impl ::std::convert::From<&Self> for OperationsHashsumPrefer {
11341        fn from(value: &OperationsHashsumPrefer) -> Self {
11342            value.clone()
11343        }
11344    }
11345
11346    impl ::std::fmt::Display for OperationsHashsumPrefer {
11347        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11348            match *self {
11349                Self::RespondAsync => f.write_str("respond-async"),
11350            }
11351        }
11352    }
11353
11354    impl ::std::str::FromStr for OperationsHashsumPrefer {
11355        type Err = self::error::ConversionError;
11356        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11357            match value {
11358                "respond-async" => Ok(Self::RespondAsync),
11359                _ => Err("invalid value".into()),
11360            }
11361        }
11362    }
11363
11364    impl ::std::convert::TryFrom<&str> for OperationsHashsumPrefer {
11365        type Error = self::error::ConversionError;
11366        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11367            value.parse()
11368        }
11369    }
11370
11371    impl ::std::convert::TryFrom<&::std::string::String> for OperationsHashsumPrefer {
11372        type Error = self::error::ConversionError;
11373        fn try_from(
11374            value: &::std::string::String,
11375        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11376            value.parse()
11377        }
11378    }
11379
11380    impl ::std::convert::TryFrom<::std::string::String> for OperationsHashsumPrefer {
11381        type Error = self::error::ConversionError;
11382        fn try_from(
11383            value: ::std::string::String,
11384        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11385            value.parse()
11386        }
11387    }
11388
11389    ///`OperationsHashsumRequest`
11390    ///
11391    /// <details><summary>JSON schema</summary>
11392    ///
11393    /// ```json
11394    ///{
11395    ///  "type": "object",
11396    ///  "properties": {
11397    ///    "_async": {
11398    ///      "description": "Run the command asynchronously. Returns a job id
11399    /// immediately.",
11400    ///      "type": "boolean"
11401    ///    },
11402    ///    "_group": {
11403    ///      "description": "Assign the request to a custom stats group.",
11404    ///      "type": "string"
11405    ///    },
11406    ///    "base64": {
11407    ///      "description": "Set to true to emit hash values in base64 rather
11408    /// than hexadecimal.",
11409    ///      "type": "boolean"
11410    ///    },
11411    ///    "download": {
11412    ///      "description": "Set to true to force reading the data instead of
11413    /// using remote checksums.",
11414    ///      "type": "boolean"
11415    ///    },
11416    ///    "fs": {
11417    ///      "description": "Remote name or path to hash, such as `drive:` or
11418    /// `/`.",
11419    ///      "type": "string"
11420    ///    },
11421    ///    "hashType": {
11422    ///      "description": "Hash algorithm to use, e.g. `md5`, `sha1`, or
11423    /// another supported name.",
11424    ///      "type": "string"
11425    ///    }
11426    ///  }
11427    ///}
11428    /// ```
11429    /// </details>
11430    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11431    pub struct OperationsHashsumRequest {
11432        ///Run the command asynchronously. Returns a job id immediately.
11433        #[serde(
11434            rename = "_async",
11435            default,
11436            skip_serializing_if = "::std::option::Option::is_none"
11437        )]
11438        pub async_: ::std::option::Option<bool>,
11439        ///Set to true to emit hash values in base64 rather than hexadecimal.
11440        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11441        pub base64: ::std::option::Option<bool>,
11442        ///Set to true to force reading the data instead of using remote
11443        /// checksums.
11444        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11445        pub download: ::std::option::Option<bool>,
11446        ///Remote name or path to hash, such as `drive:` or `/`.
11447        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11448        pub fs: ::std::option::Option<::std::string::String>,
11449        ///Assign the request to a custom stats group.
11450        #[serde(
11451            rename = "_group",
11452            default,
11453            skip_serializing_if = "::std::option::Option::is_none"
11454        )]
11455        pub group: ::std::option::Option<::std::string::String>,
11456        ///Hash algorithm to use, e.g. `md5`, `sha1`, or another supported
11457        /// name.
11458        #[serde(
11459            rename = "hashType",
11460            default,
11461            skip_serializing_if = "::std::option::Option::is_none"
11462        )]
11463        pub hash_type: ::std::option::Option<::std::string::String>,
11464    }
11465
11466    impl ::std::convert::From<&OperationsHashsumRequest> for OperationsHashsumRequest {
11467        fn from(value: &OperationsHashsumRequest) -> Self {
11468            value.clone()
11469        }
11470    }
11471
11472    impl ::std::default::Default for OperationsHashsumRequest {
11473        fn default() -> Self {
11474            Self {
11475                async_: Default::default(),
11476                base64: Default::default(),
11477                download: Default::default(),
11478                fs: Default::default(),
11479                group: Default::default(),
11480                hash_type: Default::default(),
11481            }
11482        }
11483    }
11484
11485    ///`OperationsHashsumResponse`
11486    ///
11487    /// <details><summary>JSON schema</summary>
11488    ///
11489    /// ```json
11490    ///{
11491    ///  "type": "object",
11492    ///  "required": [
11493    ///    "hashType",
11494    ///    "hashsum"
11495    ///  ],
11496    ///  "properties": {
11497    ///    "hashType": {
11498    ///      "type": "string"
11499    ///    },
11500    ///    "hashsum": {
11501    ///      "type": "array",
11502    ///      "items": {
11503    ///        "type": "string"
11504    ///      }
11505    ///    }
11506    ///  }
11507    ///}
11508    /// ```
11509    /// </details>
11510    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11511    pub struct OperationsHashsumResponse {
11512        #[serde(rename = "hashType")]
11513        pub hash_type: ::std::string::String,
11514        pub hashsum: ::std::vec::Vec<::std::string::String>,
11515    }
11516
11517    impl ::std::convert::From<&OperationsHashsumResponse> for OperationsHashsumResponse {
11518        fn from(value: &OperationsHashsumResponse) -> Self {
11519            value.clone()
11520        }
11521    }
11522
11523    ///`OperationsHashsumfilePrefer`
11524    ///
11525    /// <details><summary>JSON schema</summary>
11526    ///
11527    /// ```json
11528    ///{
11529    ///  "type": "string",
11530    ///  "enum": [
11531    ///    "respond-async"
11532    ///  ]
11533    ///}
11534    /// ```
11535    /// </details>
11536    #[derive(
11537        :: serde :: Deserialize,
11538        :: serde :: Serialize,
11539        Clone,
11540        Copy,
11541        Debug,
11542        Eq,
11543        Hash,
11544        Ord,
11545        PartialEq,
11546        PartialOrd,
11547    )]
11548    pub enum OperationsHashsumfilePrefer {
11549        #[serde(rename = "respond-async")]
11550        RespondAsync,
11551    }
11552
11553    impl ::std::convert::From<&Self> for OperationsHashsumfilePrefer {
11554        fn from(value: &OperationsHashsumfilePrefer) -> Self {
11555            value.clone()
11556        }
11557    }
11558
11559    impl ::std::fmt::Display for OperationsHashsumfilePrefer {
11560        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11561            match *self {
11562                Self::RespondAsync => f.write_str("respond-async"),
11563            }
11564        }
11565    }
11566
11567    impl ::std::str::FromStr for OperationsHashsumfilePrefer {
11568        type Err = self::error::ConversionError;
11569        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11570            match value {
11571                "respond-async" => Ok(Self::RespondAsync),
11572                _ => Err("invalid value".into()),
11573            }
11574        }
11575    }
11576
11577    impl ::std::convert::TryFrom<&str> for OperationsHashsumfilePrefer {
11578        type Error = self::error::ConversionError;
11579        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11580            value.parse()
11581        }
11582    }
11583
11584    impl ::std::convert::TryFrom<&::std::string::String> for OperationsHashsumfilePrefer {
11585        type Error = self::error::ConversionError;
11586        fn try_from(
11587            value: &::std::string::String,
11588        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11589            value.parse()
11590        }
11591    }
11592
11593    impl ::std::convert::TryFrom<::std::string::String> for OperationsHashsumfilePrefer {
11594        type Error = self::error::ConversionError;
11595        fn try_from(
11596            value: ::std::string::String,
11597        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11598            value.parse()
11599        }
11600    }
11601
11602    ///`OperationsHashsumfileRequest`
11603    ///
11604    /// <details><summary>JSON schema</summary>
11605    ///
11606    /// ```json
11607    ///{
11608    ///  "type": "object",
11609    ///  "properties": {
11610    ///    "_async": {
11611    ///      "description": "Run the command asynchronously. Returns a job id
11612    /// immediately.",
11613    ///      "type": "boolean"
11614    ///    },
11615    ///    "_group": {
11616    ///      "description": "Assign the request to a custom stats group.",
11617    ///      "type": "string"
11618    ///    },
11619    ///    "base64": {
11620    ///      "description": "Set to true to emit the hash value in base64 rather
11621    /// than hexadecimal.",
11622    ///      "type": "boolean"
11623    ///    },
11624    ///    "download": {
11625    ///      "description": "Set to true to force reading the data instead of
11626    /// using remote checksums.",
11627    ///      "type": "boolean"
11628    ///    },
11629    ///    "fs": {
11630    ///      "description": "Remote name or path containing the file to hash.",
11631    ///      "type": "string"
11632    ///    },
11633    ///    "hashType": {
11634    ///      "description": "Hash algorithm to use, e.g. `md5`, `sha1`, or
11635    /// another supported name.",
11636    ///      "type": "string"
11637    ///    },
11638    ///    "remote": {
11639    ///      "description": "Path to the specific file within `fs` to hash.",
11640    ///      "type": "string"
11641    ///    }
11642    ///  }
11643    ///}
11644    /// ```
11645    /// </details>
11646    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11647    pub struct OperationsHashsumfileRequest {
11648        ///Run the command asynchronously. Returns a job id immediately.
11649        #[serde(
11650            rename = "_async",
11651            default,
11652            skip_serializing_if = "::std::option::Option::is_none"
11653        )]
11654        pub async_: ::std::option::Option<bool>,
11655        ///Set to true to emit the hash value in base64 rather than
11656        /// hexadecimal.
11657        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11658        pub base64: ::std::option::Option<bool>,
11659        ///Set to true to force reading the data instead of using remote
11660        /// checksums.
11661        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11662        pub download: ::std::option::Option<bool>,
11663        ///Remote name or path containing the file to hash.
11664        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11665        pub fs: ::std::option::Option<::std::string::String>,
11666        ///Assign the request to a custom stats group.
11667        #[serde(
11668            rename = "_group",
11669            default,
11670            skip_serializing_if = "::std::option::Option::is_none"
11671        )]
11672        pub group: ::std::option::Option<::std::string::String>,
11673        ///Hash algorithm to use, e.g. `md5`, `sha1`, or another supported
11674        /// name.
11675        #[serde(
11676            rename = "hashType",
11677            default,
11678            skip_serializing_if = "::std::option::Option::is_none"
11679        )]
11680        pub hash_type: ::std::option::Option<::std::string::String>,
11681        ///Path to the specific file within `fs` to hash.
11682        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11683        pub remote: ::std::option::Option<::std::string::String>,
11684    }
11685
11686    impl ::std::convert::From<&OperationsHashsumfileRequest> for OperationsHashsumfileRequest {
11687        fn from(value: &OperationsHashsumfileRequest) -> Self {
11688            value.clone()
11689        }
11690    }
11691
11692    impl ::std::default::Default for OperationsHashsumfileRequest {
11693        fn default() -> Self {
11694            Self {
11695                async_: Default::default(),
11696                base64: Default::default(),
11697                download: Default::default(),
11698                fs: Default::default(),
11699                group: Default::default(),
11700                hash_type: Default::default(),
11701                remote: Default::default(),
11702            }
11703        }
11704    }
11705
11706    ///`OperationsHashsumfileResponse`
11707    ///
11708    /// <details><summary>JSON schema</summary>
11709    ///
11710    /// ```json
11711    ///{
11712    ///  "type": "object",
11713    ///  "required": [
11714    ///    "hash",
11715    ///    "hashType"
11716    ///  ],
11717    ///  "properties": {
11718    ///    "hash": {
11719    ///      "description": "The hash value of the file.",
11720    ///      "type": "string"
11721    ///    },
11722    ///    "hashType": {
11723    ///      "description": "The hash algorithm that was used.",
11724    ///      "type": "string"
11725    ///    }
11726    ///  }
11727    ///}
11728    /// ```
11729    /// </details>
11730    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11731    pub struct OperationsHashsumfileResponse {
11732        ///The hash value of the file.
11733        pub hash: ::std::string::String,
11734        ///The hash algorithm that was used.
11735        #[serde(rename = "hashType")]
11736        pub hash_type: ::std::string::String,
11737    }
11738
11739    impl ::std::convert::From<&OperationsHashsumfileResponse> for OperationsHashsumfileResponse {
11740        fn from(value: &OperationsHashsumfileResponse) -> Self {
11741            value.clone()
11742        }
11743    }
11744
11745    ///`OperationsListPrefer`
11746    ///
11747    /// <details><summary>JSON schema</summary>
11748    ///
11749    /// ```json
11750    ///{
11751    ///  "type": "string",
11752    ///  "enum": [
11753    ///    "respond-async"
11754    ///  ]
11755    ///}
11756    /// ```
11757    /// </details>
11758    #[derive(
11759        :: serde :: Deserialize,
11760        :: serde :: Serialize,
11761        Clone,
11762        Copy,
11763        Debug,
11764        Eq,
11765        Hash,
11766        Ord,
11767        PartialEq,
11768        PartialOrd,
11769    )]
11770    pub enum OperationsListPrefer {
11771        #[serde(rename = "respond-async")]
11772        RespondAsync,
11773    }
11774
11775    impl ::std::convert::From<&Self> for OperationsListPrefer {
11776        fn from(value: &OperationsListPrefer) -> Self {
11777            value.clone()
11778        }
11779    }
11780
11781    impl ::std::fmt::Display for OperationsListPrefer {
11782        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11783            match *self {
11784                Self::RespondAsync => f.write_str("respond-async"),
11785            }
11786        }
11787    }
11788
11789    impl ::std::str::FromStr for OperationsListPrefer {
11790        type Err = self::error::ConversionError;
11791        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11792            match value {
11793                "respond-async" => Ok(Self::RespondAsync),
11794                _ => Err("invalid value".into()),
11795            }
11796        }
11797    }
11798
11799    impl ::std::convert::TryFrom<&str> for OperationsListPrefer {
11800        type Error = self::error::ConversionError;
11801        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
11802            value.parse()
11803        }
11804    }
11805
11806    impl ::std::convert::TryFrom<&::std::string::String> for OperationsListPrefer {
11807        type Error = self::error::ConversionError;
11808        fn try_from(
11809            value: &::std::string::String,
11810        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11811            value.parse()
11812        }
11813    }
11814
11815    impl ::std::convert::TryFrom<::std::string::String> for OperationsListPrefer {
11816        type Error = self::error::ConversionError;
11817        fn try_from(
11818            value: ::std::string::String,
11819        ) -> ::std::result::Result<Self, self::error::ConversionError> {
11820            value.parse()
11821        }
11822    }
11823
11824    ///`OperationsListRequest`
11825    ///
11826    /// <details><summary>JSON schema</summary>
11827    ///
11828    /// ```json
11829    ///{
11830    ///  "type": "object",
11831    ///  "properties": {
11832    ///    "_async": {
11833    ///      "description": "Run the command asynchronously. Returns a job id
11834    /// immediately.",
11835    ///      "type": "boolean"
11836    ///    },
11837    ///    "_config": {
11838    ///      "description": "JSON encoded config overrides applied for this call
11839    /// only.",
11840    ///      "type": "string"
11841    ///    },
11842    ///    "_filter": {
11843    ///      "description": "JSON encoded filter overrides applied for this call
11844    /// only.",
11845    ///      "type": "string"
11846    ///    },
11847    ///    "_group": {
11848    ///      "description": "Assign the request to a custom stats group.",
11849    ///      "type": "string"
11850    ///    },
11851    ///    "dirsOnly": {
11852    ///      "description": "Set to true to return only directory entries.",
11853    ///      "type": "boolean"
11854    ///    },
11855    ///    "filesOnly": {
11856    ///      "description": "Set to true to return only file entries.",
11857    ///      "type": "boolean"
11858    ///    },
11859    ///    "fs": {
11860    ///      "description": "Remote name or path to list, for example
11861    /// `drive:`.",
11862    ///      "type": "string"
11863    ///    },
11864    ///    "hashTypes": {
11865    ///      "description": "Specify one or more hash algorithms to include when
11866    /// `showHash` is true (e.g. `md5`).",
11867    ///      "type": "array",
11868    ///      "items": {
11869    ///        "type": "string"
11870    ///      }
11871    ///    },
11872    ///    "metadata": {
11873    ///      "description": "Set to true to include backend-provided metadata
11874    /// maps.",
11875    ///      "type": "boolean"
11876    ///    },
11877    ///    "noMimeType": {
11878    ///      "description": "Set to true to omit MIME type detection.",
11879    ///      "type": "boolean"
11880    ///    },
11881    ///    "noModTime": {
11882    ///      "description": "Set to true to omit modification times for faster
11883    /// listings on some backends.",
11884    ///      "type": "boolean"
11885    ///    },
11886    ///    "opt": {
11887    ///      "description": "Optional JSON-encoded object of listing flags (e.g.
11888    /// `{ \"recurse\": true, \"showHash\": true }`).",
11889    ///      "type": "string"
11890    ///    },
11891    ///    "recurse": {
11892    ///      "description": "Set to true to list directories recursively.",
11893    ///      "type": "boolean"
11894    ///    },
11895    ///    "remote": {
11896    ///      "description": "Directory path within `fs` to list; leave empty to
11897    /// target the root.",
11898    ///      "type": "string"
11899    ///    },
11900    ///    "showEncrypted": {
11901    ///      "description": "Set to true to include encrypted names when using
11902    /// crypt remotes.",
11903    ///      "type": "boolean"
11904    ///    },
11905    ///    "showHash": {
11906    ///      "description": "Set to true to include hash digests for each
11907    /// entry.",
11908    ///      "type": "boolean"
11909    ///    },
11910    ///    "showOrigIDs": {
11911    ///      "description": "Set to true to include original backend identifiers
11912    /// where available.",
11913    ///      "type": "boolean"
11914    ///    }
11915    ///  }
11916    ///}
11917    /// ```
11918    /// </details>
11919    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
11920    pub struct OperationsListRequest {
11921        ///Run the command asynchronously. Returns a job id immediately.
11922        #[serde(
11923            rename = "_async",
11924            default,
11925            skip_serializing_if = "::std::option::Option::is_none"
11926        )]
11927        pub async_: ::std::option::Option<bool>,
11928        ///JSON encoded config overrides applied for this call only.
11929        #[serde(
11930            rename = "_config",
11931            default,
11932            skip_serializing_if = "::std::option::Option::is_none"
11933        )]
11934        pub config: ::std::option::Option<::std::string::String>,
11935        ///Set to true to return only directory entries.
11936        #[serde(
11937            rename = "dirsOnly",
11938            default,
11939            skip_serializing_if = "::std::option::Option::is_none"
11940        )]
11941        pub dirs_only: ::std::option::Option<bool>,
11942        ///Set to true to return only file entries.
11943        #[serde(
11944            rename = "filesOnly",
11945            default,
11946            skip_serializing_if = "::std::option::Option::is_none"
11947        )]
11948        pub files_only: ::std::option::Option<bool>,
11949        ///JSON encoded filter overrides applied for this call only.
11950        #[serde(
11951            rename = "_filter",
11952            default,
11953            skip_serializing_if = "::std::option::Option::is_none"
11954        )]
11955        pub filter: ::std::option::Option<::std::string::String>,
11956        ///Remote name or path to list, for example `drive:`.
11957        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11958        pub fs: ::std::option::Option<::std::string::String>,
11959        ///Assign the request to a custom stats group.
11960        #[serde(
11961            rename = "_group",
11962            default,
11963            skip_serializing_if = "::std::option::Option::is_none"
11964        )]
11965        pub group: ::std::option::Option<::std::string::String>,
11966        ///Specify one or more hash algorithms to include when `showHash` is
11967        /// true (e.g. `md5`).
11968        #[serde(
11969            rename = "hashTypes",
11970            default,
11971            skip_serializing_if = "::std::vec::Vec::is_empty"
11972        )]
11973        pub hash_types: ::std::vec::Vec<::std::string::String>,
11974        ///Set to true to include backend-provided metadata maps.
11975        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11976        pub metadata: ::std::option::Option<bool>,
11977        ///Set to true to omit MIME type detection.
11978        #[serde(
11979            rename = "noMimeType",
11980            default,
11981            skip_serializing_if = "::std::option::Option::is_none"
11982        )]
11983        pub no_mime_type: ::std::option::Option<bool>,
11984        ///Set to true to omit modification times for faster listings on some
11985        /// backends.
11986        #[serde(
11987            rename = "noModTime",
11988            default,
11989            skip_serializing_if = "::std::option::Option::is_none"
11990        )]
11991        pub no_mod_time: ::std::option::Option<bool>,
11992        ///Optional JSON-encoded object of listing flags (e.g. `{ "recurse":
11993        /// true, "showHash": true }`).
11994        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11995        pub opt: ::std::option::Option<::std::string::String>,
11996        ///Set to true to list directories recursively.
11997        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
11998        pub recurse: ::std::option::Option<bool>,
11999        ///Directory path within `fs` to list; leave empty to target the root.
12000        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12001        pub remote: ::std::option::Option<::std::string::String>,
12002        ///Set to true to include encrypted names when using crypt remotes.
12003        #[serde(
12004            rename = "showEncrypted",
12005            default,
12006            skip_serializing_if = "::std::option::Option::is_none"
12007        )]
12008        pub show_encrypted: ::std::option::Option<bool>,
12009        ///Set to true to include hash digests for each entry.
12010        #[serde(
12011            rename = "showHash",
12012            default,
12013            skip_serializing_if = "::std::option::Option::is_none"
12014        )]
12015        pub show_hash: ::std::option::Option<bool>,
12016        ///Set to true to include original backend identifiers where available.
12017        #[serde(
12018            rename = "showOrigIDs",
12019            default,
12020            skip_serializing_if = "::std::option::Option::is_none"
12021        )]
12022        pub show_orig_i_ds: ::std::option::Option<bool>,
12023    }
12024
12025    impl ::std::convert::From<&OperationsListRequest> for OperationsListRequest {
12026        fn from(value: &OperationsListRequest) -> Self {
12027            value.clone()
12028        }
12029    }
12030
12031    impl ::std::default::Default for OperationsListRequest {
12032        fn default() -> Self {
12033            Self {
12034                async_: Default::default(),
12035                config: Default::default(),
12036                dirs_only: Default::default(),
12037                files_only: Default::default(),
12038                filter: Default::default(),
12039                fs: Default::default(),
12040                group: Default::default(),
12041                hash_types: Default::default(),
12042                metadata: Default::default(),
12043                no_mime_type: Default::default(),
12044                no_mod_time: Default::default(),
12045                opt: Default::default(),
12046                recurse: Default::default(),
12047                remote: Default::default(),
12048                show_encrypted: Default::default(),
12049                show_hash: Default::default(),
12050                show_orig_i_ds: Default::default(),
12051            }
12052        }
12053    }
12054
12055    ///`OperationsListResponse`
12056    ///
12057    /// <details><summary>JSON schema</summary>
12058    ///
12059    /// ```json
12060    ///{
12061    ///  "type": "object",
12062    ///  "required": [
12063    ///    "list"
12064    ///  ],
12065    ///  "properties": {
12066    ///    "list": {
12067    ///      "description": "Array of entries equivalent to the items returned
12068    /// by `rclone lsjson`.",
12069    ///      "type": "array",
12070    ///      "items": {
12071    ///        "type": "object",
12072    ///        "required": [
12073    ///          "IsDir",
12074    ///          "Name",
12075    ///          "Path"
12076    ///        ],
12077    ///        "properties": {
12078    ///          "Encrypted": {
12079    ///            "description": "Encrypted entry name when using crypt
12080    /// remotes.",
12081    ///            "type": "string"
12082    ///          },
12083    ///          "EncryptedPath": {
12084    ///            "description": "Encrypted path when using crypt remotes.",
12085    ///            "type": "string"
12086    ///          },
12087    ///          "Hashes": {
12088    ///            "description": "Hash digests keyed by algorithm when
12089    /// requested.",
12090    ///            "type": "object",
12091    ///            "additionalProperties": {
12092    ///              "type": "string"
12093    ///            }
12094    ///          },
12095    ///          "ID": {
12096    ///            "description": "Backend-specific identifier when provided.",
12097    ///            "type": "string"
12098    ///          },
12099    ///          "IsBucket": {
12100    ///            "description": "True for bucket/root entries on bucket-based
12101    /// remotes.",
12102    ///            "type": "boolean"
12103    ///          },
12104    ///          "IsDir": {
12105    ///            "description": "True if the entry represents a directory.",
12106    ///            "type": "boolean"
12107    ///          },
12108    ///          "Metadata": {
12109    ///            "description": "Backend-provided metadata map.",
12110    ///            "type": "object",
12111    ///            "additionalProperties": {}
12112    ///          },
12113    ///          "MimeType": {
12114    ///            "description": "MIME type where available.",
12115    ///            "type": "string"
12116    ///          },
12117    ///          "ModTime": {
12118    ///            "description": "Modification timestamp in RFC3339 format.",
12119    ///            "type": "string"
12120    ///          },
12121    ///          "Name": {
12122    ///            "description": "Base name of the entry.",
12123    ///            "type": "string"
12124    ///          },
12125    ///          "OrigID": {
12126    ///            "description": "Original backend identifier when recorded.",
12127    ///            "type": "string"
12128    ///          },
12129    ///          "Path": {
12130    ///            "description": "Path relative to the requested remote root.",
12131    ///            "type": "string"
12132    ///          },
12133    ///          "Size": {
12134    ///            "description": "Object size in bytes.",
12135    ///            "type": "number"
12136    ///          },
12137    ///          "Tier": {
12138    ///            "description": "Storage class or tier, if supplied by the
12139    /// backend.",
12140    ///            "type": "string"
12141    ///          }
12142    ///        }
12143    ///      }
12144    ///    }
12145    ///  }
12146    ///}
12147    /// ```
12148    /// </details>
12149    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12150    pub struct OperationsListResponse {
12151        ///Array of entries equivalent to the items returned by `rclone
12152        /// lsjson`.
12153        pub list: ::std::vec::Vec<OperationsListResponseListItem>,
12154    }
12155
12156    impl ::std::convert::From<&OperationsListResponse> for OperationsListResponse {
12157        fn from(value: &OperationsListResponse) -> Self {
12158            value.clone()
12159        }
12160    }
12161
12162    ///`OperationsListResponseListItem`
12163    ///
12164    /// <details><summary>JSON schema</summary>
12165    ///
12166    /// ```json
12167    ///{
12168    ///  "type": "object",
12169    ///  "required": [
12170    ///    "IsDir",
12171    ///    "Name",
12172    ///    "Path"
12173    ///  ],
12174    ///  "properties": {
12175    ///    "Encrypted": {
12176    ///      "description": "Encrypted entry name when using crypt remotes.",
12177    ///      "type": "string"
12178    ///    },
12179    ///    "EncryptedPath": {
12180    ///      "description": "Encrypted path when using crypt remotes.",
12181    ///      "type": "string"
12182    ///    },
12183    ///    "Hashes": {
12184    ///      "description": "Hash digests keyed by algorithm when requested.",
12185    ///      "type": "object",
12186    ///      "additionalProperties": {
12187    ///        "type": "string"
12188    ///      }
12189    ///    },
12190    ///    "ID": {
12191    ///      "description": "Backend-specific identifier when provided.",
12192    ///      "type": "string"
12193    ///    },
12194    ///    "IsBucket": {
12195    ///      "description": "True for bucket/root entries on bucket-based
12196    /// remotes.",
12197    ///      "type": "boolean"
12198    ///    },
12199    ///    "IsDir": {
12200    ///      "description": "True if the entry represents a directory.",
12201    ///      "type": "boolean"
12202    ///    },
12203    ///    "Metadata": {
12204    ///      "description": "Backend-provided metadata map.",
12205    ///      "type": "object",
12206    ///      "additionalProperties": {}
12207    ///    },
12208    ///    "MimeType": {
12209    ///      "description": "MIME type where available.",
12210    ///      "type": "string"
12211    ///    },
12212    ///    "ModTime": {
12213    ///      "description": "Modification timestamp in RFC3339 format.",
12214    ///      "type": "string"
12215    ///    },
12216    ///    "Name": {
12217    ///      "description": "Base name of the entry.",
12218    ///      "type": "string"
12219    ///    },
12220    ///    "OrigID": {
12221    ///      "description": "Original backend identifier when recorded.",
12222    ///      "type": "string"
12223    ///    },
12224    ///    "Path": {
12225    ///      "description": "Path relative to the requested remote root.",
12226    ///      "type": "string"
12227    ///    },
12228    ///    "Size": {
12229    ///      "description": "Object size in bytes.",
12230    ///      "type": "number"
12231    ///    },
12232    ///    "Tier": {
12233    ///      "description": "Storage class or tier, if supplied by the
12234    /// backend.",
12235    ///      "type": "string"
12236    ///    }
12237    ///  }
12238    ///}
12239    /// ```
12240    /// </details>
12241    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12242    pub struct OperationsListResponseListItem {
12243        ///Encrypted entry name when using crypt remotes.
12244        #[serde(
12245            rename = "Encrypted",
12246            default,
12247            skip_serializing_if = "::std::option::Option::is_none"
12248        )]
12249        pub encrypted: ::std::option::Option<::std::string::String>,
12250        ///Encrypted path when using crypt remotes.
12251        #[serde(
12252            rename = "EncryptedPath",
12253            default,
12254            skip_serializing_if = "::std::option::Option::is_none"
12255        )]
12256        pub encrypted_path: ::std::option::Option<::std::string::String>,
12257        ///Hash digests keyed by algorithm when requested.
12258        #[serde(
12259            rename = "Hashes",
12260            default,
12261            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
12262        )]
12263        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
12264        ///Backend-specific identifier when provided.
12265        #[serde(
12266            rename = "ID",
12267            default,
12268            skip_serializing_if = "::std::option::Option::is_none"
12269        )]
12270        pub id: ::std::option::Option<::std::string::String>,
12271        ///True for bucket/root entries on bucket-based remotes.
12272        #[serde(
12273            rename = "IsBucket",
12274            default,
12275            skip_serializing_if = "::std::option::Option::is_none"
12276        )]
12277        pub is_bucket: ::std::option::Option<bool>,
12278        ///True if the entry represents a directory.
12279        #[serde(rename = "IsDir")]
12280        pub is_dir: bool,
12281        ///Backend-provided metadata map.
12282        #[serde(
12283            rename = "Metadata",
12284            default,
12285            skip_serializing_if = "::serde_json::Map::is_empty"
12286        )]
12287        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
12288        ///MIME type where available.
12289        #[serde(
12290            rename = "MimeType",
12291            default,
12292            skip_serializing_if = "::std::option::Option::is_none"
12293        )]
12294        pub mime_type: ::std::option::Option<::std::string::String>,
12295        ///Modification timestamp in RFC3339 format.
12296        #[serde(
12297            rename = "ModTime",
12298            default,
12299            skip_serializing_if = "::std::option::Option::is_none"
12300        )]
12301        pub mod_time: ::std::option::Option<::std::string::String>,
12302        ///Base name of the entry.
12303        #[serde(rename = "Name")]
12304        pub name: ::std::string::String,
12305        ///Original backend identifier when recorded.
12306        #[serde(
12307            rename = "OrigID",
12308            default,
12309            skip_serializing_if = "::std::option::Option::is_none"
12310        )]
12311        pub orig_id: ::std::option::Option<::std::string::String>,
12312        ///Path relative to the requested remote root.
12313        #[serde(rename = "Path")]
12314        pub path: ::std::string::String,
12315        #[serde(
12316            rename = "Size",
12317            default,
12318            skip_serializing_if = "::std::option::Option::is_none"
12319        )]
12320        pub size: ::std::option::Option<f64>,
12321        ///Storage class or tier, if supplied by the backend.
12322        #[serde(
12323            rename = "Tier",
12324            default,
12325            skip_serializing_if = "::std::option::Option::is_none"
12326        )]
12327        pub tier: ::std::option::Option<::std::string::String>,
12328    }
12329
12330    impl ::std::convert::From<&OperationsListResponseListItem> for OperationsListResponseListItem {
12331        fn from(value: &OperationsListResponseListItem) -> Self {
12332            value.clone()
12333        }
12334    }
12335
12336    ///`OperationsMkdirPrefer`
12337    ///
12338    /// <details><summary>JSON schema</summary>
12339    ///
12340    /// ```json
12341    ///{
12342    ///  "type": "string",
12343    ///  "enum": [
12344    ///    "respond-async"
12345    ///  ]
12346    ///}
12347    /// ```
12348    /// </details>
12349    #[derive(
12350        :: serde :: Deserialize,
12351        :: serde :: Serialize,
12352        Clone,
12353        Copy,
12354        Debug,
12355        Eq,
12356        Hash,
12357        Ord,
12358        PartialEq,
12359        PartialOrd,
12360    )]
12361    pub enum OperationsMkdirPrefer {
12362        #[serde(rename = "respond-async")]
12363        RespondAsync,
12364    }
12365
12366    impl ::std::convert::From<&Self> for OperationsMkdirPrefer {
12367        fn from(value: &OperationsMkdirPrefer) -> Self {
12368            value.clone()
12369        }
12370    }
12371
12372    impl ::std::fmt::Display for OperationsMkdirPrefer {
12373        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12374            match *self {
12375                Self::RespondAsync => f.write_str("respond-async"),
12376            }
12377        }
12378    }
12379
12380    impl ::std::str::FromStr for OperationsMkdirPrefer {
12381        type Err = self::error::ConversionError;
12382        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12383            match value {
12384                "respond-async" => Ok(Self::RespondAsync),
12385                _ => Err("invalid value".into()),
12386            }
12387        }
12388    }
12389
12390    impl ::std::convert::TryFrom<&str> for OperationsMkdirPrefer {
12391        type Error = self::error::ConversionError;
12392        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12393            value.parse()
12394        }
12395    }
12396
12397    impl ::std::convert::TryFrom<&::std::string::String> for OperationsMkdirPrefer {
12398        type Error = self::error::ConversionError;
12399        fn try_from(
12400            value: &::std::string::String,
12401        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12402            value.parse()
12403        }
12404    }
12405
12406    impl ::std::convert::TryFrom<::std::string::String> for OperationsMkdirPrefer {
12407        type Error = self::error::ConversionError;
12408        fn try_from(
12409            value: ::std::string::String,
12410        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12411            value.parse()
12412        }
12413    }
12414
12415    ///`OperationsMkdirRequest`
12416    ///
12417    /// <details><summary>JSON schema</summary>
12418    ///
12419    /// ```json
12420    ///{
12421    ///  "type": "object",
12422    ///  "properties": {
12423    ///    "_async": {
12424    ///      "description": "Run the command asynchronously. Returns a job id
12425    /// immediately.",
12426    ///      "type": "boolean"
12427    ///    },
12428    ///    "_group": {
12429    ///      "description": "Assign the request to a custom stats group.",
12430    ///      "type": "string"
12431    ///    },
12432    ///    "fs": {
12433    ///      "description": "Remote name or path in which to create a
12434    /// directory.",
12435    ///      "type": "string"
12436    ///    },
12437    ///    "remote": {
12438    ///      "description": "Directory path within `fs` to create.",
12439    ///      "type": "string"
12440    ///    }
12441    ///  }
12442    ///}
12443    /// ```
12444    /// </details>
12445    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12446    pub struct OperationsMkdirRequest {
12447        ///Run the command asynchronously. Returns a job id immediately.
12448        #[serde(
12449            rename = "_async",
12450            default,
12451            skip_serializing_if = "::std::option::Option::is_none"
12452        )]
12453        pub async_: ::std::option::Option<bool>,
12454        ///Remote name or path in which to create a directory.
12455        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12456        pub fs: ::std::option::Option<::std::string::String>,
12457        ///Assign the request to a custom stats group.
12458        #[serde(
12459            rename = "_group",
12460            default,
12461            skip_serializing_if = "::std::option::Option::is_none"
12462        )]
12463        pub group: ::std::option::Option<::std::string::String>,
12464        ///Directory path within `fs` to create.
12465        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12466        pub remote: ::std::option::Option<::std::string::String>,
12467    }
12468
12469    impl ::std::convert::From<&OperationsMkdirRequest> for OperationsMkdirRequest {
12470        fn from(value: &OperationsMkdirRequest) -> Self {
12471            value.clone()
12472        }
12473    }
12474
12475    impl ::std::default::Default for OperationsMkdirRequest {
12476        fn default() -> Self {
12477            Self {
12478                async_: Default::default(),
12479                fs: Default::default(),
12480                group: Default::default(),
12481                remote: Default::default(),
12482            }
12483        }
12484    }
12485
12486    ///`OperationsMovefilePrefer`
12487    ///
12488    /// <details><summary>JSON schema</summary>
12489    ///
12490    /// ```json
12491    ///{
12492    ///  "type": "string",
12493    ///  "enum": [
12494    ///    "respond-async"
12495    ///  ]
12496    ///}
12497    /// ```
12498    /// </details>
12499    #[derive(
12500        :: serde :: Deserialize,
12501        :: serde :: Serialize,
12502        Clone,
12503        Copy,
12504        Debug,
12505        Eq,
12506        Hash,
12507        Ord,
12508        PartialEq,
12509        PartialOrd,
12510    )]
12511    pub enum OperationsMovefilePrefer {
12512        #[serde(rename = "respond-async")]
12513        RespondAsync,
12514    }
12515
12516    impl ::std::convert::From<&Self> for OperationsMovefilePrefer {
12517        fn from(value: &OperationsMovefilePrefer) -> Self {
12518            value.clone()
12519        }
12520    }
12521
12522    impl ::std::fmt::Display for OperationsMovefilePrefer {
12523        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12524            match *self {
12525                Self::RespondAsync => f.write_str("respond-async"),
12526            }
12527        }
12528    }
12529
12530    impl ::std::str::FromStr for OperationsMovefilePrefer {
12531        type Err = self::error::ConversionError;
12532        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12533            match value {
12534                "respond-async" => Ok(Self::RespondAsync),
12535                _ => Err("invalid value".into()),
12536            }
12537        }
12538    }
12539
12540    impl ::std::convert::TryFrom<&str> for OperationsMovefilePrefer {
12541        type Error = self::error::ConversionError;
12542        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12543            value.parse()
12544        }
12545    }
12546
12547    impl ::std::convert::TryFrom<&::std::string::String> for OperationsMovefilePrefer {
12548        type Error = self::error::ConversionError;
12549        fn try_from(
12550            value: &::std::string::String,
12551        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12552            value.parse()
12553        }
12554    }
12555
12556    impl ::std::convert::TryFrom<::std::string::String> for OperationsMovefilePrefer {
12557        type Error = self::error::ConversionError;
12558        fn try_from(
12559            value: ::std::string::String,
12560        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12561            value.parse()
12562        }
12563    }
12564
12565    ///`OperationsMovefileRequest`
12566    ///
12567    /// <details><summary>JSON schema</summary>
12568    ///
12569    /// ```json
12570    ///{
12571    ///  "type": "object",
12572    ///  "properties": {
12573    ///    "_async": {
12574    ///      "description": "Run the command asynchronously. Returns a job id
12575    /// immediately.",
12576    ///      "type": "boolean"
12577    ///    },
12578    ///    "_group": {
12579    ///      "description": "Assign the request to a custom stats group.",
12580    ///      "type": "string"
12581    ///    },
12582    ///    "dstFs": {
12583    ///      "description": "Destination remote name or path where the file will
12584    /// be moved.",
12585    ///      "type": "string"
12586    ///    },
12587    ///    "dstRemote": {
12588    ///      "description": "Destination path within `dstFs` for the moved
12589    /// object.",
12590    ///      "type": "string"
12591    ///    },
12592    ///    "srcFs": {
12593    ///      "description": "Source remote name or path containing the file to
12594    /// move.",
12595    ///      "type": "string"
12596    ///    },
12597    ///    "srcRemote": {
12598    ///      "description": "Path to the source object within `srcFs`.",
12599    ///      "type": "string"
12600    ///    }
12601    ///  }
12602    ///}
12603    /// ```
12604    /// </details>
12605    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12606    pub struct OperationsMovefileRequest {
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        ///Destination remote name or path where the file will be moved.
12615        #[serde(
12616            rename = "dstFs",
12617            default,
12618            skip_serializing_if = "::std::option::Option::is_none"
12619        )]
12620        pub dst_fs: ::std::option::Option<::std::string::String>,
12621        ///Destination path within `dstFs` for the moved object.
12622        #[serde(
12623            rename = "dstRemote",
12624            default,
12625            skip_serializing_if = "::std::option::Option::is_none"
12626        )]
12627        pub dst_remote: ::std::option::Option<::std::string::String>,
12628        ///Assign the request to a custom stats group.
12629        #[serde(
12630            rename = "_group",
12631            default,
12632            skip_serializing_if = "::std::option::Option::is_none"
12633        )]
12634        pub group: ::std::option::Option<::std::string::String>,
12635        ///Source remote name or path containing the file to move.
12636        #[serde(
12637            rename = "srcFs",
12638            default,
12639            skip_serializing_if = "::std::option::Option::is_none"
12640        )]
12641        pub src_fs: ::std::option::Option<::std::string::String>,
12642        ///Path to the source object within `srcFs`.
12643        #[serde(
12644            rename = "srcRemote",
12645            default,
12646            skip_serializing_if = "::std::option::Option::is_none"
12647        )]
12648        pub src_remote: ::std::option::Option<::std::string::String>,
12649    }
12650
12651    impl ::std::convert::From<&OperationsMovefileRequest> for OperationsMovefileRequest {
12652        fn from(value: &OperationsMovefileRequest) -> Self {
12653            value.clone()
12654        }
12655    }
12656
12657    impl ::std::default::Default for OperationsMovefileRequest {
12658        fn default() -> Self {
12659            Self {
12660                async_: Default::default(),
12661                dst_fs: Default::default(),
12662                dst_remote: Default::default(),
12663                group: Default::default(),
12664                src_fs: Default::default(),
12665                src_remote: Default::default(),
12666            }
12667        }
12668    }
12669
12670    ///`OperationsPubliclinkPrefer`
12671    ///
12672    /// <details><summary>JSON schema</summary>
12673    ///
12674    /// ```json
12675    ///{
12676    ///  "type": "string",
12677    ///  "enum": [
12678    ///    "respond-async"
12679    ///  ]
12680    ///}
12681    /// ```
12682    /// </details>
12683    #[derive(
12684        :: serde :: Deserialize,
12685        :: serde :: Serialize,
12686        Clone,
12687        Copy,
12688        Debug,
12689        Eq,
12690        Hash,
12691        Ord,
12692        PartialEq,
12693        PartialOrd,
12694    )]
12695    pub enum OperationsPubliclinkPrefer {
12696        #[serde(rename = "respond-async")]
12697        RespondAsync,
12698    }
12699
12700    impl ::std::convert::From<&Self> for OperationsPubliclinkPrefer {
12701        fn from(value: &OperationsPubliclinkPrefer) -> Self {
12702            value.clone()
12703        }
12704    }
12705
12706    impl ::std::fmt::Display for OperationsPubliclinkPrefer {
12707        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12708            match *self {
12709                Self::RespondAsync => f.write_str("respond-async"),
12710            }
12711        }
12712    }
12713
12714    impl ::std::str::FromStr for OperationsPubliclinkPrefer {
12715        type Err = self::error::ConversionError;
12716        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12717            match value {
12718                "respond-async" => Ok(Self::RespondAsync),
12719                _ => Err("invalid value".into()),
12720            }
12721        }
12722    }
12723
12724    impl ::std::convert::TryFrom<&str> for OperationsPubliclinkPrefer {
12725        type Error = self::error::ConversionError;
12726        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12727            value.parse()
12728        }
12729    }
12730
12731    impl ::std::convert::TryFrom<&::std::string::String> for OperationsPubliclinkPrefer {
12732        type Error = self::error::ConversionError;
12733        fn try_from(
12734            value: &::std::string::String,
12735        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12736            value.parse()
12737        }
12738    }
12739
12740    impl ::std::convert::TryFrom<::std::string::String> for OperationsPubliclinkPrefer {
12741        type Error = self::error::ConversionError;
12742        fn try_from(
12743            value: ::std::string::String,
12744        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12745            value.parse()
12746        }
12747    }
12748
12749    ///`OperationsPubliclinkRequest`
12750    ///
12751    /// <details><summary>JSON schema</summary>
12752    ///
12753    /// ```json
12754    ///{
12755    ///  "type": "object",
12756    ///  "properties": {
12757    ///    "_async": {
12758    ///      "description": "Run the command asynchronously. Returns a job id
12759    /// immediately.",
12760    ///      "type": "boolean"
12761    ///    },
12762    ///    "_group": {
12763    ///      "description": "Assign the request to a custom stats group.",
12764    ///      "type": "string"
12765    ///    },
12766    ///    "expire": {
12767    ///      "description": "Optional expiration time for the public link,
12768    /// formatted as supported by the backend.",
12769    ///      "type": "string"
12770    ///    },
12771    ///    "fs": {
12772    ///      "description": "Remote name or path hosting the object for which to
12773    /// manage a public link.",
12774    ///      "type": "string"
12775    ///    },
12776    ///    "remote": {
12777    ///      "description": "Path within `fs` to the object for which to create
12778    /// or remove a public link.",
12779    ///      "type": "string"
12780    ///    },
12781    ///    "unlink": {
12782    ///      "description": "Set to true to remove an existing public link
12783    /// instead of creating one.",
12784    ///      "type": "boolean"
12785    ///    }
12786    ///  }
12787    ///}
12788    /// ```
12789    /// </details>
12790    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12791    pub struct OperationsPubliclinkRequest {
12792        ///Run the command asynchronously. Returns a job id immediately.
12793        #[serde(
12794            rename = "_async",
12795            default,
12796            skip_serializing_if = "::std::option::Option::is_none"
12797        )]
12798        pub async_: ::std::option::Option<bool>,
12799        ///Optional expiration time for the public link, formatted as supported
12800        /// by the backend.
12801        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12802        pub expire: ::std::option::Option<::std::string::String>,
12803        ///Remote name or path hosting the object for which to manage a public
12804        /// link.
12805        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12806        pub fs: ::std::option::Option<::std::string::String>,
12807        ///Assign the request to a custom stats group.
12808        #[serde(
12809            rename = "_group",
12810            default,
12811            skip_serializing_if = "::std::option::Option::is_none"
12812        )]
12813        pub group: ::std::option::Option<::std::string::String>,
12814        ///Path within `fs` to the object for which to create or remove a
12815        /// public link.
12816        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12817        pub remote: ::std::option::Option<::std::string::String>,
12818        ///Set to true to remove an existing public link instead of creating
12819        /// one.
12820        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
12821        pub unlink: ::std::option::Option<bool>,
12822    }
12823
12824    impl ::std::convert::From<&OperationsPubliclinkRequest> for OperationsPubliclinkRequest {
12825        fn from(value: &OperationsPubliclinkRequest) -> Self {
12826            value.clone()
12827        }
12828    }
12829
12830    impl ::std::default::Default for OperationsPubliclinkRequest {
12831        fn default() -> Self {
12832            Self {
12833                async_: Default::default(),
12834                expire: Default::default(),
12835                fs: Default::default(),
12836                group: Default::default(),
12837                remote: Default::default(),
12838                unlink: Default::default(),
12839            }
12840        }
12841    }
12842
12843    ///`OperationsPubliclinkResponse`
12844    ///
12845    /// <details><summary>JSON schema</summary>
12846    ///
12847    /// ```json
12848    ///{
12849    ///  "type": "object",
12850    ///  "required": [
12851    ///    "url"
12852    ///  ],
12853    ///  "properties": {
12854    ///    "url": {
12855    ///      "type": "string",
12856    ///      "format": "uri"
12857    ///    }
12858    ///  }
12859    ///}
12860    /// ```
12861    /// </details>
12862    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12863    pub struct OperationsPubliclinkResponse {
12864        pub url: ::std::string::String,
12865    }
12866
12867    impl ::std::convert::From<&OperationsPubliclinkResponse> for OperationsPubliclinkResponse {
12868        fn from(value: &OperationsPubliclinkResponse) -> Self {
12869            value.clone()
12870        }
12871    }
12872
12873    ///`OperationsPurgePrefer`
12874    ///
12875    /// <details><summary>JSON schema</summary>
12876    ///
12877    /// ```json
12878    ///{
12879    ///  "type": "string",
12880    ///  "enum": [
12881    ///    "respond-async"
12882    ///  ]
12883    ///}
12884    /// ```
12885    /// </details>
12886    #[derive(
12887        :: serde :: Deserialize,
12888        :: serde :: Serialize,
12889        Clone,
12890        Copy,
12891        Debug,
12892        Eq,
12893        Hash,
12894        Ord,
12895        PartialEq,
12896        PartialOrd,
12897    )]
12898    pub enum OperationsPurgePrefer {
12899        #[serde(rename = "respond-async")]
12900        RespondAsync,
12901    }
12902
12903    impl ::std::convert::From<&Self> for OperationsPurgePrefer {
12904        fn from(value: &OperationsPurgePrefer) -> Self {
12905            value.clone()
12906        }
12907    }
12908
12909    impl ::std::fmt::Display for OperationsPurgePrefer {
12910        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12911            match *self {
12912                Self::RespondAsync => f.write_str("respond-async"),
12913            }
12914        }
12915    }
12916
12917    impl ::std::str::FromStr for OperationsPurgePrefer {
12918        type Err = self::error::ConversionError;
12919        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12920            match value {
12921                "respond-async" => Ok(Self::RespondAsync),
12922                _ => Err("invalid value".into()),
12923            }
12924        }
12925    }
12926
12927    impl ::std::convert::TryFrom<&str> for OperationsPurgePrefer {
12928        type Error = self::error::ConversionError;
12929        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
12930            value.parse()
12931        }
12932    }
12933
12934    impl ::std::convert::TryFrom<&::std::string::String> for OperationsPurgePrefer {
12935        type Error = self::error::ConversionError;
12936        fn try_from(
12937            value: &::std::string::String,
12938        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12939            value.parse()
12940        }
12941    }
12942
12943    impl ::std::convert::TryFrom<::std::string::String> for OperationsPurgePrefer {
12944        type Error = self::error::ConversionError;
12945        fn try_from(
12946            value: ::std::string::String,
12947        ) -> ::std::result::Result<Self, self::error::ConversionError> {
12948            value.parse()
12949        }
12950    }
12951
12952    ///`OperationsPurgeRequest`
12953    ///
12954    /// <details><summary>JSON schema</summary>
12955    ///
12956    /// ```json
12957    ///{
12958    ///  "type": "object",
12959    ///  "properties": {
12960    ///    "_async": {
12961    ///      "description": "Run the command asynchronously. Returns a job id
12962    /// immediately.",
12963    ///      "type": "boolean"
12964    ///    },
12965    ///    "_config": {
12966    ///      "description": "JSON encoded config overrides applied for this call
12967    /// only.",
12968    ///      "type": "string"
12969    ///    },
12970    ///    "_filter": {
12971    ///      "description": "JSON encoded filter overrides applied for this call
12972    /// only.",
12973    ///      "type": "string"
12974    ///    },
12975    ///    "_group": {
12976    ///      "description": "Assign the request to a custom stats group.",
12977    ///      "type": "string"
12978    ///    },
12979    ///    "fs": {
12980    ///      "description": "Remote name or path from which to remove all
12981    /// contents.",
12982    ///      "type": "string"
12983    ///    },
12984    ///    "remote": {
12985    ///      "description": "Path within `fs` whose contents should be purged.",
12986    ///      "type": "string"
12987    ///    }
12988    ///  }
12989    ///}
12990    /// ```
12991    /// </details>
12992    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
12993    pub struct OperationsPurgeRequest {
12994        ///Run the command asynchronously. Returns a job id immediately.
12995        #[serde(
12996            rename = "_async",
12997            default,
12998            skip_serializing_if = "::std::option::Option::is_none"
12999        )]
13000        pub async_: ::std::option::Option<bool>,
13001        ///JSON encoded config overrides applied for this call only.
13002        #[serde(
13003            rename = "_config",
13004            default,
13005            skip_serializing_if = "::std::option::Option::is_none"
13006        )]
13007        pub config: ::std::option::Option<::std::string::String>,
13008        ///JSON encoded filter overrides applied for this call only.
13009        #[serde(
13010            rename = "_filter",
13011            default,
13012            skip_serializing_if = "::std::option::Option::is_none"
13013        )]
13014        pub filter: ::std::option::Option<::std::string::String>,
13015        ///Remote name or path from which to remove all contents.
13016        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13017        pub fs: ::std::option::Option<::std::string::String>,
13018        ///Assign the request to a custom stats group.
13019        #[serde(
13020            rename = "_group",
13021            default,
13022            skip_serializing_if = "::std::option::Option::is_none"
13023        )]
13024        pub group: ::std::option::Option<::std::string::String>,
13025        ///Path within `fs` whose contents should be purged.
13026        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13027        pub remote: ::std::option::Option<::std::string::String>,
13028    }
13029
13030    impl ::std::convert::From<&OperationsPurgeRequest> for OperationsPurgeRequest {
13031        fn from(value: &OperationsPurgeRequest) -> Self {
13032            value.clone()
13033        }
13034    }
13035
13036    impl ::std::default::Default for OperationsPurgeRequest {
13037        fn default() -> Self {
13038            Self {
13039                async_: Default::default(),
13040                config: Default::default(),
13041                filter: Default::default(),
13042                fs: Default::default(),
13043                group: Default::default(),
13044                remote: Default::default(),
13045            }
13046        }
13047    }
13048
13049    ///`OperationsRmdirPrefer`
13050    ///
13051    /// <details><summary>JSON schema</summary>
13052    ///
13053    /// ```json
13054    ///{
13055    ///  "type": "string",
13056    ///  "enum": [
13057    ///    "respond-async"
13058    ///  ]
13059    ///}
13060    /// ```
13061    /// </details>
13062    #[derive(
13063        :: serde :: Deserialize,
13064        :: serde :: Serialize,
13065        Clone,
13066        Copy,
13067        Debug,
13068        Eq,
13069        Hash,
13070        Ord,
13071        PartialEq,
13072        PartialOrd,
13073    )]
13074    pub enum OperationsRmdirPrefer {
13075        #[serde(rename = "respond-async")]
13076        RespondAsync,
13077    }
13078
13079    impl ::std::convert::From<&Self> for OperationsRmdirPrefer {
13080        fn from(value: &OperationsRmdirPrefer) -> Self {
13081            value.clone()
13082        }
13083    }
13084
13085    impl ::std::fmt::Display for OperationsRmdirPrefer {
13086        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13087            match *self {
13088                Self::RespondAsync => f.write_str("respond-async"),
13089            }
13090        }
13091    }
13092
13093    impl ::std::str::FromStr for OperationsRmdirPrefer {
13094        type Err = self::error::ConversionError;
13095        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13096            match value {
13097                "respond-async" => Ok(Self::RespondAsync),
13098                _ => Err("invalid value".into()),
13099            }
13100        }
13101    }
13102
13103    impl ::std::convert::TryFrom<&str> for OperationsRmdirPrefer {
13104        type Error = self::error::ConversionError;
13105        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13106            value.parse()
13107        }
13108    }
13109
13110    impl ::std::convert::TryFrom<&::std::string::String> for OperationsRmdirPrefer {
13111        type Error = self::error::ConversionError;
13112        fn try_from(
13113            value: &::std::string::String,
13114        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13115            value.parse()
13116        }
13117    }
13118
13119    impl ::std::convert::TryFrom<::std::string::String> for OperationsRmdirPrefer {
13120        type Error = self::error::ConversionError;
13121        fn try_from(
13122            value: ::std::string::String,
13123        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13124            value.parse()
13125        }
13126    }
13127
13128    ///`OperationsRmdirRequest`
13129    ///
13130    /// <details><summary>JSON schema</summary>
13131    ///
13132    /// ```json
13133    ///{
13134    ///  "type": "object",
13135    ///  "properties": {
13136    ///    "_async": {
13137    ///      "description": "Run the command asynchronously. Returns a job id
13138    /// immediately.",
13139    ///      "type": "boolean"
13140    ///    },
13141    ///    "_group": {
13142    ///      "description": "Assign the request to a custom stats group.",
13143    ///      "type": "string"
13144    ///    },
13145    ///    "fs": {
13146    ///      "description": "Remote name or path containing the directory to
13147    /// remove.",
13148    ///      "type": "string"
13149    ///    },
13150    ///    "remote": {
13151    ///      "description": "Directory path within `fs` to delete.",
13152    ///      "type": "string"
13153    ///    }
13154    ///  }
13155    ///}
13156    /// ```
13157    /// </details>
13158    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13159    pub struct OperationsRmdirRequest {
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        ///Remote name or path containing the directory to remove.
13168        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13169        pub fs: ::std::option::Option<::std::string::String>,
13170        ///Assign the request to a custom stats group.
13171        #[serde(
13172            rename = "_group",
13173            default,
13174            skip_serializing_if = "::std::option::Option::is_none"
13175        )]
13176        pub group: ::std::option::Option<::std::string::String>,
13177        ///Directory path within `fs` to delete.
13178        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13179        pub remote: ::std::option::Option<::std::string::String>,
13180    }
13181
13182    impl ::std::convert::From<&OperationsRmdirRequest> for OperationsRmdirRequest {
13183        fn from(value: &OperationsRmdirRequest) -> Self {
13184            value.clone()
13185        }
13186    }
13187
13188    impl ::std::default::Default for OperationsRmdirRequest {
13189        fn default() -> Self {
13190            Self {
13191                async_: Default::default(),
13192                fs: Default::default(),
13193                group: Default::default(),
13194                remote: Default::default(),
13195            }
13196        }
13197    }
13198
13199    ///`OperationsRmdirsPrefer`
13200    ///
13201    /// <details><summary>JSON schema</summary>
13202    ///
13203    /// ```json
13204    ///{
13205    ///  "type": "string",
13206    ///  "enum": [
13207    ///    "respond-async"
13208    ///  ]
13209    ///}
13210    /// ```
13211    /// </details>
13212    #[derive(
13213        :: serde :: Deserialize,
13214        :: serde :: Serialize,
13215        Clone,
13216        Copy,
13217        Debug,
13218        Eq,
13219        Hash,
13220        Ord,
13221        PartialEq,
13222        PartialOrd,
13223    )]
13224    pub enum OperationsRmdirsPrefer {
13225        #[serde(rename = "respond-async")]
13226        RespondAsync,
13227    }
13228
13229    impl ::std::convert::From<&Self> for OperationsRmdirsPrefer {
13230        fn from(value: &OperationsRmdirsPrefer) -> Self {
13231            value.clone()
13232        }
13233    }
13234
13235    impl ::std::fmt::Display for OperationsRmdirsPrefer {
13236        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13237            match *self {
13238                Self::RespondAsync => f.write_str("respond-async"),
13239            }
13240        }
13241    }
13242
13243    impl ::std::str::FromStr for OperationsRmdirsPrefer {
13244        type Err = self::error::ConversionError;
13245        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13246            match value {
13247                "respond-async" => Ok(Self::RespondAsync),
13248                _ => Err("invalid value".into()),
13249            }
13250        }
13251    }
13252
13253    impl ::std::convert::TryFrom<&str> for OperationsRmdirsPrefer {
13254        type Error = self::error::ConversionError;
13255        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13256            value.parse()
13257        }
13258    }
13259
13260    impl ::std::convert::TryFrom<&::std::string::String> for OperationsRmdirsPrefer {
13261        type Error = self::error::ConversionError;
13262        fn try_from(
13263            value: &::std::string::String,
13264        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13265            value.parse()
13266        }
13267    }
13268
13269    impl ::std::convert::TryFrom<::std::string::String> for OperationsRmdirsPrefer {
13270        type Error = self::error::ConversionError;
13271        fn try_from(
13272            value: ::std::string::String,
13273        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13274            value.parse()
13275        }
13276    }
13277
13278    ///`OperationsRmdirsRequest`
13279    ///
13280    /// <details><summary>JSON schema</summary>
13281    ///
13282    /// ```json
13283    ///{
13284    ///  "type": "object",
13285    ///  "properties": {
13286    ///    "_async": {
13287    ///      "description": "Run the command asynchronously. Returns a job id
13288    /// immediately.",
13289    ///      "type": "boolean"
13290    ///    },
13291    ///    "_group": {
13292    ///      "description": "Assign the request to a custom stats group.",
13293    ///      "type": "string"
13294    ///    },
13295    ///    "fs": {
13296    ///      "description": "Remote name or path to scan for empty
13297    /// directories.",
13298    ///      "type": "string"
13299    ///    },
13300    ///    "leaveRoot": {
13301    ///      "description": "Set to true to preserve the top-level directory
13302    /// even if empty.",
13303    ///      "type": "boolean"
13304    ///    },
13305    ///    "remote": {
13306    ///      "description": "Path within `fs` whose empty subdirectories should
13307    /// be removed.",
13308    ///      "type": "string"
13309    ///    }
13310    ///  }
13311    ///}
13312    /// ```
13313    /// </details>
13314    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13315    pub struct OperationsRmdirsRequest {
13316        ///Run the command asynchronously. Returns a job id immediately.
13317        #[serde(
13318            rename = "_async",
13319            default,
13320            skip_serializing_if = "::std::option::Option::is_none"
13321        )]
13322        pub async_: ::std::option::Option<bool>,
13323        ///Remote name or path to scan for empty directories.
13324        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13325        pub fs: ::std::option::Option<::std::string::String>,
13326        ///Assign the request to a custom stats group.
13327        #[serde(
13328            rename = "_group",
13329            default,
13330            skip_serializing_if = "::std::option::Option::is_none"
13331        )]
13332        pub group: ::std::option::Option<::std::string::String>,
13333        ///Set to true to preserve the top-level directory even if empty.
13334        #[serde(
13335            rename = "leaveRoot",
13336            default,
13337            skip_serializing_if = "::std::option::Option::is_none"
13338        )]
13339        pub leave_root: ::std::option::Option<bool>,
13340        ///Path within `fs` whose empty subdirectories should be removed.
13341        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13342        pub remote: ::std::option::Option<::std::string::String>,
13343    }
13344
13345    impl ::std::convert::From<&OperationsRmdirsRequest> for OperationsRmdirsRequest {
13346        fn from(value: &OperationsRmdirsRequest) -> Self {
13347            value.clone()
13348        }
13349    }
13350
13351    impl ::std::default::Default for OperationsRmdirsRequest {
13352        fn default() -> Self {
13353            Self {
13354                async_: Default::default(),
13355                fs: Default::default(),
13356                group: Default::default(),
13357                leave_root: Default::default(),
13358                remote: Default::default(),
13359            }
13360        }
13361    }
13362
13363    ///`OperationsSettierPrefer`
13364    ///
13365    /// <details><summary>JSON schema</summary>
13366    ///
13367    /// ```json
13368    ///{
13369    ///  "type": "string",
13370    ///  "enum": [
13371    ///    "respond-async"
13372    ///  ]
13373    ///}
13374    /// ```
13375    /// </details>
13376    #[derive(
13377        :: serde :: Deserialize,
13378        :: serde :: Serialize,
13379        Clone,
13380        Copy,
13381        Debug,
13382        Eq,
13383        Hash,
13384        Ord,
13385        PartialEq,
13386        PartialOrd,
13387    )]
13388    pub enum OperationsSettierPrefer {
13389        #[serde(rename = "respond-async")]
13390        RespondAsync,
13391    }
13392
13393    impl ::std::convert::From<&Self> for OperationsSettierPrefer {
13394        fn from(value: &OperationsSettierPrefer) -> Self {
13395            value.clone()
13396        }
13397    }
13398
13399    impl ::std::fmt::Display for OperationsSettierPrefer {
13400        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13401            match *self {
13402                Self::RespondAsync => f.write_str("respond-async"),
13403            }
13404        }
13405    }
13406
13407    impl ::std::str::FromStr for OperationsSettierPrefer {
13408        type Err = self::error::ConversionError;
13409        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13410            match value {
13411                "respond-async" => Ok(Self::RespondAsync),
13412                _ => Err("invalid value".into()),
13413            }
13414        }
13415    }
13416
13417    impl ::std::convert::TryFrom<&str> for OperationsSettierPrefer {
13418        type Error = self::error::ConversionError;
13419        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13420            value.parse()
13421        }
13422    }
13423
13424    impl ::std::convert::TryFrom<&::std::string::String> for OperationsSettierPrefer {
13425        type Error = self::error::ConversionError;
13426        fn try_from(
13427            value: &::std::string::String,
13428        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13429            value.parse()
13430        }
13431    }
13432
13433    impl ::std::convert::TryFrom<::std::string::String> for OperationsSettierPrefer {
13434        type Error = self::error::ConversionError;
13435        fn try_from(
13436            value: ::std::string::String,
13437        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13438            value.parse()
13439        }
13440    }
13441
13442    ///`OperationsSettierRequest`
13443    ///
13444    /// <details><summary>JSON schema</summary>
13445    ///
13446    /// ```json
13447    ///{
13448    ///  "type": "object",
13449    ///  "properties": {
13450    ///    "_async": {
13451    ///      "description": "Run the command asynchronously. Returns a job id
13452    /// immediately.",
13453    ///      "type": "boolean"
13454    ///    },
13455    ///    "_group": {
13456    ///      "description": "Assign the request to a custom stats group.",
13457    ///      "type": "string"
13458    ///    },
13459    ///    "fs": {
13460    ///      "description": "Remote name or path whose storage class tier should
13461    /// be changed.",
13462    ///      "type": "string"
13463    ///    }
13464    ///  }
13465    ///}
13466    /// ```
13467    /// </details>
13468    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13469    pub struct OperationsSettierRequest {
13470        ///Run the command asynchronously. Returns a job id immediately.
13471        #[serde(
13472            rename = "_async",
13473            default,
13474            skip_serializing_if = "::std::option::Option::is_none"
13475        )]
13476        pub async_: ::std::option::Option<bool>,
13477        ///Remote name or path whose storage class tier should be changed.
13478        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13479        pub fs: ::std::option::Option<::std::string::String>,
13480        ///Assign the request to a custom stats group.
13481        #[serde(
13482            rename = "_group",
13483            default,
13484            skip_serializing_if = "::std::option::Option::is_none"
13485        )]
13486        pub group: ::std::option::Option<::std::string::String>,
13487    }
13488
13489    impl ::std::convert::From<&OperationsSettierRequest> for OperationsSettierRequest {
13490        fn from(value: &OperationsSettierRequest) -> Self {
13491            value.clone()
13492        }
13493    }
13494
13495    impl ::std::default::Default for OperationsSettierRequest {
13496        fn default() -> Self {
13497            Self {
13498                async_: Default::default(),
13499                fs: Default::default(),
13500                group: Default::default(),
13501            }
13502        }
13503    }
13504
13505    ///`OperationsSettierfilePrefer`
13506    ///
13507    /// <details><summary>JSON schema</summary>
13508    ///
13509    /// ```json
13510    ///{
13511    ///  "type": "string",
13512    ///  "enum": [
13513    ///    "respond-async"
13514    ///  ]
13515    ///}
13516    /// ```
13517    /// </details>
13518    #[derive(
13519        :: serde :: Deserialize,
13520        :: serde :: Serialize,
13521        Clone,
13522        Copy,
13523        Debug,
13524        Eq,
13525        Hash,
13526        Ord,
13527        PartialEq,
13528        PartialOrd,
13529    )]
13530    pub enum OperationsSettierfilePrefer {
13531        #[serde(rename = "respond-async")]
13532        RespondAsync,
13533    }
13534
13535    impl ::std::convert::From<&Self> for OperationsSettierfilePrefer {
13536        fn from(value: &OperationsSettierfilePrefer) -> Self {
13537            value.clone()
13538        }
13539    }
13540
13541    impl ::std::fmt::Display for OperationsSettierfilePrefer {
13542        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13543            match *self {
13544                Self::RespondAsync => f.write_str("respond-async"),
13545            }
13546        }
13547    }
13548
13549    impl ::std::str::FromStr for OperationsSettierfilePrefer {
13550        type Err = self::error::ConversionError;
13551        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13552            match value {
13553                "respond-async" => Ok(Self::RespondAsync),
13554                _ => Err("invalid value".into()),
13555            }
13556        }
13557    }
13558
13559    impl ::std::convert::TryFrom<&str> for OperationsSettierfilePrefer {
13560        type Error = self::error::ConversionError;
13561        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13562            value.parse()
13563        }
13564    }
13565
13566    impl ::std::convert::TryFrom<&::std::string::String> for OperationsSettierfilePrefer {
13567        type Error = self::error::ConversionError;
13568        fn try_from(
13569            value: &::std::string::String,
13570        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13571            value.parse()
13572        }
13573    }
13574
13575    impl ::std::convert::TryFrom<::std::string::String> for OperationsSettierfilePrefer {
13576        type Error = self::error::ConversionError;
13577        fn try_from(
13578            value: ::std::string::String,
13579        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13580            value.parse()
13581        }
13582    }
13583
13584    ///`OperationsSettierfileRequest`
13585    ///
13586    /// <details><summary>JSON schema</summary>
13587    ///
13588    /// ```json
13589    ///{
13590    ///  "type": "object",
13591    ///  "properties": {
13592    ///    "_async": {
13593    ///      "description": "Run the command asynchronously. Returns a job id
13594    /// immediately.",
13595    ///      "type": "boolean"
13596    ///    },
13597    ///    "_group": {
13598    ///      "description": "Assign the request to a custom stats group.",
13599    ///      "type": "string"
13600    ///    },
13601    ///    "fs": {
13602    ///      "description": "Remote name or path that contains the object whose
13603    /// tier should change.",
13604    ///      "type": "string"
13605    ///    },
13606    ///    "remote": {
13607    ///      "description": "Path within `fs` to the object whose storage class
13608    /// tier should be updated.",
13609    ///      "type": "string"
13610    ///    }
13611    ///  }
13612    ///}
13613    /// ```
13614    /// </details>
13615    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13616    pub struct OperationsSettierfileRequest {
13617        ///Run the command asynchronously. Returns a job id immediately.
13618        #[serde(
13619            rename = "_async",
13620            default,
13621            skip_serializing_if = "::std::option::Option::is_none"
13622        )]
13623        pub async_: ::std::option::Option<bool>,
13624        ///Remote name or path that contains the object whose tier should
13625        /// change.
13626        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13627        pub fs: ::std::option::Option<::std::string::String>,
13628        ///Assign the request to a custom stats group.
13629        #[serde(
13630            rename = "_group",
13631            default,
13632            skip_serializing_if = "::std::option::Option::is_none"
13633        )]
13634        pub group: ::std::option::Option<::std::string::String>,
13635        ///Path within `fs` to the object whose storage class tier should be
13636        /// updated.
13637        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13638        pub remote: ::std::option::Option<::std::string::String>,
13639    }
13640
13641    impl ::std::convert::From<&OperationsSettierfileRequest> for OperationsSettierfileRequest {
13642        fn from(value: &OperationsSettierfileRequest) -> Self {
13643            value.clone()
13644        }
13645    }
13646
13647    impl ::std::default::Default for OperationsSettierfileRequest {
13648        fn default() -> Self {
13649            Self {
13650                async_: Default::default(),
13651                fs: Default::default(),
13652                group: Default::default(),
13653                remote: Default::default(),
13654            }
13655        }
13656    }
13657
13658    ///`OperationsSizePrefer`
13659    ///
13660    /// <details><summary>JSON schema</summary>
13661    ///
13662    /// ```json
13663    ///{
13664    ///  "type": "string",
13665    ///  "enum": [
13666    ///    "respond-async"
13667    ///  ]
13668    ///}
13669    /// ```
13670    /// </details>
13671    #[derive(
13672        :: serde :: Deserialize,
13673        :: serde :: Serialize,
13674        Clone,
13675        Copy,
13676        Debug,
13677        Eq,
13678        Hash,
13679        Ord,
13680        PartialEq,
13681        PartialOrd,
13682    )]
13683    pub enum OperationsSizePrefer {
13684        #[serde(rename = "respond-async")]
13685        RespondAsync,
13686    }
13687
13688    impl ::std::convert::From<&Self> for OperationsSizePrefer {
13689        fn from(value: &OperationsSizePrefer) -> Self {
13690            value.clone()
13691        }
13692    }
13693
13694    impl ::std::fmt::Display for OperationsSizePrefer {
13695        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13696            match *self {
13697                Self::RespondAsync => f.write_str("respond-async"),
13698            }
13699        }
13700    }
13701
13702    impl ::std::str::FromStr for OperationsSizePrefer {
13703        type Err = self::error::ConversionError;
13704        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13705            match value {
13706                "respond-async" => Ok(Self::RespondAsync),
13707                _ => Err("invalid value".into()),
13708            }
13709        }
13710    }
13711
13712    impl ::std::convert::TryFrom<&str> for OperationsSizePrefer {
13713        type Error = self::error::ConversionError;
13714        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13715            value.parse()
13716        }
13717    }
13718
13719    impl ::std::convert::TryFrom<&::std::string::String> for OperationsSizePrefer {
13720        type Error = self::error::ConversionError;
13721        fn try_from(
13722            value: &::std::string::String,
13723        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13724            value.parse()
13725        }
13726    }
13727
13728    impl ::std::convert::TryFrom<::std::string::String> for OperationsSizePrefer {
13729        type Error = self::error::ConversionError;
13730        fn try_from(
13731            value: ::std::string::String,
13732        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13733            value.parse()
13734        }
13735    }
13736
13737    ///`OperationsSizeRequest`
13738    ///
13739    /// <details><summary>JSON schema</summary>
13740    ///
13741    /// ```json
13742    ///{
13743    ///  "type": "object",
13744    ///  "properties": {
13745    ///    "_async": {
13746    ///      "description": "Run the command asynchronously. Returns a job id
13747    /// immediately.",
13748    ///      "type": "boolean"
13749    ///    },
13750    ///    "_group": {
13751    ///      "description": "Assign the request to a custom stats group.",
13752    ///      "type": "string"
13753    ///    },
13754    ///    "fs": {
13755    ///      "description": "Remote name or path to measure aggregate size
13756    /// information for.",
13757    ///      "type": "string"
13758    ///    }
13759    ///  }
13760    ///}
13761    /// ```
13762    /// </details>
13763    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13764    pub struct OperationsSizeRequest {
13765        ///Run the command asynchronously. Returns a job id immediately.
13766        #[serde(
13767            rename = "_async",
13768            default,
13769            skip_serializing_if = "::std::option::Option::is_none"
13770        )]
13771        pub async_: ::std::option::Option<bool>,
13772        ///Remote name or path to measure aggregate size information for.
13773        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13774        pub fs: ::std::option::Option<::std::string::String>,
13775        ///Assign the request to a custom stats group.
13776        #[serde(
13777            rename = "_group",
13778            default,
13779            skip_serializing_if = "::std::option::Option::is_none"
13780        )]
13781        pub group: ::std::option::Option<::std::string::String>,
13782    }
13783
13784    impl ::std::convert::From<&OperationsSizeRequest> for OperationsSizeRequest {
13785        fn from(value: &OperationsSizeRequest) -> Self {
13786            value.clone()
13787        }
13788    }
13789
13790    impl ::std::default::Default for OperationsSizeRequest {
13791        fn default() -> Self {
13792            Self {
13793                async_: Default::default(),
13794                fs: Default::default(),
13795                group: Default::default(),
13796            }
13797        }
13798    }
13799
13800    ///`OperationsSizeResponse`
13801    ///
13802    /// <details><summary>JSON schema</summary>
13803    ///
13804    /// ```json
13805    ///{
13806    ///  "type": "object",
13807    ///  "required": [
13808    ///    "bytes",
13809    ///    "count",
13810    ///    "sizeless"
13811    ///  ],
13812    ///  "properties": {
13813    ///    "bytes": {
13814    ///      "type": "number"
13815    ///    },
13816    ///    "count": {
13817    ///      "type": "integer"
13818    ///    },
13819    ///    "sizeless": {
13820    ///      "type": "integer"
13821    ///    }
13822    ///  }
13823    ///}
13824    /// ```
13825    /// </details>
13826    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13827    pub struct OperationsSizeResponse {
13828        pub bytes: f64,
13829        pub count: i64,
13830        pub sizeless: i64,
13831    }
13832
13833    impl ::std::convert::From<&OperationsSizeResponse> for OperationsSizeResponse {
13834        fn from(value: &OperationsSizeResponse) -> Self {
13835            value.clone()
13836        }
13837    }
13838
13839    ///`OperationsStatPrefer`
13840    ///
13841    /// <details><summary>JSON schema</summary>
13842    ///
13843    /// ```json
13844    ///{
13845    ///  "type": "string",
13846    ///  "enum": [
13847    ///    "respond-async"
13848    ///  ]
13849    ///}
13850    /// ```
13851    /// </details>
13852    #[derive(
13853        :: serde :: Deserialize,
13854        :: serde :: Serialize,
13855        Clone,
13856        Copy,
13857        Debug,
13858        Eq,
13859        Hash,
13860        Ord,
13861        PartialEq,
13862        PartialOrd,
13863    )]
13864    pub enum OperationsStatPrefer {
13865        #[serde(rename = "respond-async")]
13866        RespondAsync,
13867    }
13868
13869    impl ::std::convert::From<&Self> for OperationsStatPrefer {
13870        fn from(value: &OperationsStatPrefer) -> Self {
13871            value.clone()
13872        }
13873    }
13874
13875    impl ::std::fmt::Display for OperationsStatPrefer {
13876        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13877            match *self {
13878                Self::RespondAsync => f.write_str("respond-async"),
13879            }
13880        }
13881    }
13882
13883    impl ::std::str::FromStr for OperationsStatPrefer {
13884        type Err = self::error::ConversionError;
13885        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13886            match value {
13887                "respond-async" => Ok(Self::RespondAsync),
13888                _ => Err("invalid value".into()),
13889            }
13890        }
13891    }
13892
13893    impl ::std::convert::TryFrom<&str> for OperationsStatPrefer {
13894        type Error = self::error::ConversionError;
13895        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
13896            value.parse()
13897        }
13898    }
13899
13900    impl ::std::convert::TryFrom<&::std::string::String> for OperationsStatPrefer {
13901        type Error = self::error::ConversionError;
13902        fn try_from(
13903            value: &::std::string::String,
13904        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13905            value.parse()
13906        }
13907    }
13908
13909    impl ::std::convert::TryFrom<::std::string::String> for OperationsStatPrefer {
13910        type Error = self::error::ConversionError;
13911        fn try_from(
13912            value: ::std::string::String,
13913        ) -> ::std::result::Result<Self, self::error::ConversionError> {
13914            value.parse()
13915        }
13916    }
13917
13918    ///`OperationsStatRequest`
13919    ///
13920    /// <details><summary>JSON schema</summary>
13921    ///
13922    /// ```json
13923    ///{
13924    ///  "type": "object",
13925    ///  "properties": {
13926    ///    "_async": {
13927    ///      "description": "Run the command asynchronously. Returns a job id
13928    /// immediately.",
13929    ///      "type": "boolean"
13930    ///    },
13931    ///    "_group": {
13932    ///      "description": "Assign the request to a custom stats group.",
13933    ///      "type": "string"
13934    ///    },
13935    ///    "fs": {
13936    ///      "description": "Remote name or path that contains the item to
13937    /// inspect.",
13938    ///      "type": "string"
13939    ///    },
13940    ///    "opt": {
13941    ///      "description": "Optional JSON object of listing flags, matching
13942    /// those accepted by `operations/list`.",
13943    ///      "type": "string"
13944    ///    },
13945    ///    "remote": {
13946    ///      "description": "Path to the file or directory within `fs` to
13947    /// describe.",
13948    ///      "type": "string"
13949    ///    }
13950    ///  }
13951    ///}
13952    /// ```
13953    /// </details>
13954    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
13955    pub struct OperationsStatRequest {
13956        ///Run the command asynchronously. Returns a job id immediately.
13957        #[serde(
13958            rename = "_async",
13959            default,
13960            skip_serializing_if = "::std::option::Option::is_none"
13961        )]
13962        pub async_: ::std::option::Option<bool>,
13963        ///Remote name or path that contains the item to inspect.
13964        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13965        pub fs: ::std::option::Option<::std::string::String>,
13966        ///Assign the request to a custom stats group.
13967        #[serde(
13968            rename = "_group",
13969            default,
13970            skip_serializing_if = "::std::option::Option::is_none"
13971        )]
13972        pub group: ::std::option::Option<::std::string::String>,
13973        ///Optional JSON object of listing flags, matching those accepted by
13974        /// `operations/list`.
13975        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13976        pub opt: ::std::option::Option<::std::string::String>,
13977        ///Path to the file or directory within `fs` to describe.
13978        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
13979        pub remote: ::std::option::Option<::std::string::String>,
13980    }
13981
13982    impl ::std::convert::From<&OperationsStatRequest> for OperationsStatRequest {
13983        fn from(value: &OperationsStatRequest) -> Self {
13984            value.clone()
13985        }
13986    }
13987
13988    impl ::std::default::Default for OperationsStatRequest {
13989        fn default() -> Self {
13990            Self {
13991                async_: Default::default(),
13992                fs: Default::default(),
13993                group: Default::default(),
13994                opt: Default::default(),
13995                remote: Default::default(),
13996            }
13997        }
13998    }
13999
14000    ///`OperationsStatResponse`
14001    ///
14002    /// <details><summary>JSON schema</summary>
14003    ///
14004    /// ```json
14005    ///{
14006    ///  "type": "object",
14007    ///  "required": [
14008    ///    "item"
14009    ///  ],
14010    ///  "properties": {
14011    ///    "item": {
14012    ///      "type": [
14013    ///        "object",
14014    ///        "null"
14015    ///      ],
14016    ///      "required": [
14017    ///        "IsDir",
14018    ///        "MimeType",
14019    ///        "ModTime",
14020    ///        "Name",
14021    ///        "Path",
14022    ///        "Size"
14023    ///      ],
14024    ///      "properties": {
14025    ///        "Encrypted": {
14026    ///          "description": "Encrypted entry name when using crypt
14027    /// remotes.",
14028    ///          "type": "string"
14029    ///        },
14030    ///        "EncryptedPath": {
14031    ///          "description": "Encrypted path when using crypt remotes.",
14032    ///          "type": "string"
14033    ///        },
14034    ///        "Hashes": {
14035    ///          "description": "Hash digests keyed by algorithm when
14036    /// requested.",
14037    ///          "type": "object",
14038    ///          "additionalProperties": {
14039    ///            "type": "string"
14040    ///          }
14041    ///        },
14042    ///        "ID": {
14043    ///          "description": "Backend-specific identifier when provided.",
14044    ///          "type": "string"
14045    ///        },
14046    ///        "IsBucket": {
14047    ///          "description": "True for bucket/root entries on bucket-based
14048    /// remotes.",
14049    ///          "type": "boolean"
14050    ///        },
14051    ///        "IsDir": {
14052    ///          "description": "True if the entry is a directory.",
14053    ///          "type": "boolean"
14054    ///        },
14055    ///        "Metadata": {
14056    ///          "description": "Backend-provided metadata map.",
14057    ///          "type": "object",
14058    ///          "additionalProperties": {}
14059    ///        },
14060    ///        "MimeType": {
14061    ///          "description": "MIME type where available.",
14062    ///          "type": "string"
14063    ///        },
14064    ///        "ModTime": {
14065    ///          "description": "Modification timestamp in RFC3339 format.",
14066    ///          "type": "string"
14067    ///        },
14068    ///        "Name": {
14069    ///          "description": "Base name of the entry.",
14070    ///          "type": "string"
14071    ///        },
14072    ///        "OrigID": {
14073    ///          "description": "Original backend identifier when recorded.",
14074    ///          "type": "string"
14075    ///        },
14076    ///        "Path": {
14077    ///          "description": "Path relative to the remote root.",
14078    ///          "type": "string"
14079    ///        },
14080    ///        "Size": {
14081    ///          "description": "Object size in bytes.",
14082    ///          "type": "number"
14083    ///        },
14084    ///        "Tier": {
14085    ///          "description": "Storage class or tier, if supplied by the
14086    /// backend.",
14087    ///          "type": "string"
14088    ///        }
14089    ///      }
14090    ///    }
14091    ///  }
14092    ///}
14093    /// ```
14094    /// </details>
14095    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14096    pub struct OperationsStatResponse {
14097        pub item: ::std::option::Option<OperationsStatResponseItem>,
14098    }
14099
14100    impl ::std::convert::From<&OperationsStatResponse> for OperationsStatResponse {
14101        fn from(value: &OperationsStatResponse) -> Self {
14102            value.clone()
14103        }
14104    }
14105
14106    ///`OperationsStatResponseItem`
14107    ///
14108    /// <details><summary>JSON schema</summary>
14109    ///
14110    /// ```json
14111    ///{
14112    ///  "type": "object",
14113    ///  "required": [
14114    ///    "IsDir",
14115    ///    "MimeType",
14116    ///    "ModTime",
14117    ///    "Name",
14118    ///    "Path",
14119    ///    "Size"
14120    ///  ],
14121    ///  "properties": {
14122    ///    "Encrypted": {
14123    ///      "description": "Encrypted entry name when using crypt remotes.",
14124    ///      "type": "string"
14125    ///    },
14126    ///    "EncryptedPath": {
14127    ///      "description": "Encrypted path when using crypt remotes.",
14128    ///      "type": "string"
14129    ///    },
14130    ///    "Hashes": {
14131    ///      "description": "Hash digests keyed by algorithm when requested.",
14132    ///      "type": "object",
14133    ///      "additionalProperties": {
14134    ///        "type": "string"
14135    ///      }
14136    ///    },
14137    ///    "ID": {
14138    ///      "description": "Backend-specific identifier when provided.",
14139    ///      "type": "string"
14140    ///    },
14141    ///    "IsBucket": {
14142    ///      "description": "True for bucket/root entries on bucket-based
14143    /// remotes.",
14144    ///      "type": "boolean"
14145    ///    },
14146    ///    "IsDir": {
14147    ///      "description": "True if the entry is a directory.",
14148    ///      "type": "boolean"
14149    ///    },
14150    ///    "Metadata": {
14151    ///      "description": "Backend-provided metadata map.",
14152    ///      "type": "object",
14153    ///      "additionalProperties": {}
14154    ///    },
14155    ///    "MimeType": {
14156    ///      "description": "MIME type where available.",
14157    ///      "type": "string"
14158    ///    },
14159    ///    "ModTime": {
14160    ///      "description": "Modification timestamp in RFC3339 format.",
14161    ///      "type": "string"
14162    ///    },
14163    ///    "Name": {
14164    ///      "description": "Base name of the entry.",
14165    ///      "type": "string"
14166    ///    },
14167    ///    "OrigID": {
14168    ///      "description": "Original backend identifier when recorded.",
14169    ///      "type": "string"
14170    ///    },
14171    ///    "Path": {
14172    ///      "description": "Path relative to the remote root.",
14173    ///      "type": "string"
14174    ///    },
14175    ///    "Size": {
14176    ///      "description": "Object size in bytes.",
14177    ///      "type": "number"
14178    ///    },
14179    ///    "Tier": {
14180    ///      "description": "Storage class or tier, if supplied by the
14181    /// backend.",
14182    ///      "type": "string"
14183    ///    }
14184    ///  }
14185    ///}
14186    /// ```
14187    /// </details>
14188    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14189    pub struct OperationsStatResponseItem {
14190        ///Encrypted entry name when using crypt remotes.
14191        #[serde(
14192            rename = "Encrypted",
14193            default,
14194            skip_serializing_if = "::std::option::Option::is_none"
14195        )]
14196        pub encrypted: ::std::option::Option<::std::string::String>,
14197        ///Encrypted path when using crypt remotes.
14198        #[serde(
14199            rename = "EncryptedPath",
14200            default,
14201            skip_serializing_if = "::std::option::Option::is_none"
14202        )]
14203        pub encrypted_path: ::std::option::Option<::std::string::String>,
14204        ///Hash digests keyed by algorithm when requested.
14205        #[serde(
14206            rename = "Hashes",
14207            default,
14208            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
14209        )]
14210        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
14211        ///Backend-specific identifier when provided.
14212        #[serde(
14213            rename = "ID",
14214            default,
14215            skip_serializing_if = "::std::option::Option::is_none"
14216        )]
14217        pub id: ::std::option::Option<::std::string::String>,
14218        ///True for bucket/root entries on bucket-based remotes.
14219        #[serde(
14220            rename = "IsBucket",
14221            default,
14222            skip_serializing_if = "::std::option::Option::is_none"
14223        )]
14224        pub is_bucket: ::std::option::Option<bool>,
14225        ///True if the entry is a directory.
14226        #[serde(rename = "IsDir")]
14227        pub is_dir: bool,
14228        ///Backend-provided metadata map.
14229        #[serde(
14230            rename = "Metadata",
14231            default,
14232            skip_serializing_if = "::serde_json::Map::is_empty"
14233        )]
14234        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14235        ///MIME type where available.
14236        #[serde(rename = "MimeType")]
14237        pub mime_type: ::std::string::String,
14238        ///Modification timestamp in RFC3339 format.
14239        #[serde(rename = "ModTime")]
14240        pub mod_time: ::std::string::String,
14241        ///Base name of the entry.
14242        #[serde(rename = "Name")]
14243        pub name: ::std::string::String,
14244        ///Original backend identifier when recorded.
14245        #[serde(
14246            rename = "OrigID",
14247            default,
14248            skip_serializing_if = "::std::option::Option::is_none"
14249        )]
14250        pub orig_id: ::std::option::Option<::std::string::String>,
14251        ///Path relative to the remote root.
14252        #[serde(rename = "Path")]
14253        pub path: ::std::string::String,
14254        #[serde(rename = "Size")]
14255        pub size: f64,
14256        ///Storage class or tier, if supplied by the backend.
14257        #[serde(
14258            rename = "Tier",
14259            default,
14260            skip_serializing_if = "::std::option::Option::is_none"
14261        )]
14262        pub tier: ::std::option::Option<::std::string::String>,
14263    }
14264
14265    impl ::std::convert::From<&OperationsStatResponseItem> for OperationsStatResponseItem {
14266        fn from(value: &OperationsStatResponseItem) -> Self {
14267            value.clone()
14268        }
14269    }
14270
14271    ///`OperationsUploadfilePrefer`
14272    ///
14273    /// <details><summary>JSON schema</summary>
14274    ///
14275    /// ```json
14276    ///{
14277    ///  "type": "string",
14278    ///  "enum": [
14279    ///    "respond-async"
14280    ///  ]
14281    ///}
14282    /// ```
14283    /// </details>
14284    #[derive(
14285        :: serde :: Deserialize,
14286        :: serde :: Serialize,
14287        Clone,
14288        Copy,
14289        Debug,
14290        Eq,
14291        Hash,
14292        Ord,
14293        PartialEq,
14294        PartialOrd,
14295    )]
14296    pub enum OperationsUploadfilePrefer {
14297        #[serde(rename = "respond-async")]
14298        RespondAsync,
14299    }
14300
14301    impl ::std::convert::From<&Self> for OperationsUploadfilePrefer {
14302        fn from(value: &OperationsUploadfilePrefer) -> Self {
14303            value.clone()
14304        }
14305    }
14306
14307    impl ::std::fmt::Display for OperationsUploadfilePrefer {
14308        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14309            match *self {
14310                Self::RespondAsync => f.write_str("respond-async"),
14311            }
14312        }
14313    }
14314
14315    impl ::std::str::FromStr for OperationsUploadfilePrefer {
14316        type Err = self::error::ConversionError;
14317        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14318            match value {
14319                "respond-async" => Ok(Self::RespondAsync),
14320                _ => Err("invalid value".into()),
14321            }
14322        }
14323    }
14324
14325    impl ::std::convert::TryFrom<&str> for OperationsUploadfilePrefer {
14326        type Error = self::error::ConversionError;
14327        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14328            value.parse()
14329        }
14330    }
14331
14332    impl ::std::convert::TryFrom<&::std::string::String> for OperationsUploadfilePrefer {
14333        type Error = self::error::ConversionError;
14334        fn try_from(
14335            value: &::std::string::String,
14336        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14337            value.parse()
14338        }
14339    }
14340
14341    impl ::std::convert::TryFrom<::std::string::String> for OperationsUploadfilePrefer {
14342        type Error = self::error::ConversionError;
14343        fn try_from(
14344            value: ::std::string::String,
14345        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14346            value.parse()
14347        }
14348    }
14349
14350    ///`OptionsBlocksPrefer`
14351    ///
14352    /// <details><summary>JSON schema</summary>
14353    ///
14354    /// ```json
14355    ///{
14356    ///  "type": "string",
14357    ///  "enum": [
14358    ///    "respond-async"
14359    ///  ]
14360    ///}
14361    /// ```
14362    /// </details>
14363    #[derive(
14364        :: serde :: Deserialize,
14365        :: serde :: Serialize,
14366        Clone,
14367        Copy,
14368        Debug,
14369        Eq,
14370        Hash,
14371        Ord,
14372        PartialEq,
14373        PartialOrd,
14374    )]
14375    pub enum OptionsBlocksPrefer {
14376        #[serde(rename = "respond-async")]
14377        RespondAsync,
14378    }
14379
14380    impl ::std::convert::From<&Self> for OptionsBlocksPrefer {
14381        fn from(value: &OptionsBlocksPrefer) -> Self {
14382            value.clone()
14383        }
14384    }
14385
14386    impl ::std::fmt::Display for OptionsBlocksPrefer {
14387        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14388            match *self {
14389                Self::RespondAsync => f.write_str("respond-async"),
14390            }
14391        }
14392    }
14393
14394    impl ::std::str::FromStr for OptionsBlocksPrefer {
14395        type Err = self::error::ConversionError;
14396        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14397            match value {
14398                "respond-async" => Ok(Self::RespondAsync),
14399                _ => Err("invalid value".into()),
14400            }
14401        }
14402    }
14403
14404    impl ::std::convert::TryFrom<&str> for OptionsBlocksPrefer {
14405        type Error = self::error::ConversionError;
14406        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14407            value.parse()
14408        }
14409    }
14410
14411    impl ::std::convert::TryFrom<&::std::string::String> for OptionsBlocksPrefer {
14412        type Error = self::error::ConversionError;
14413        fn try_from(
14414            value: &::std::string::String,
14415        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14416            value.parse()
14417        }
14418    }
14419
14420    impl ::std::convert::TryFrom<::std::string::String> for OptionsBlocksPrefer {
14421        type Error = self::error::ConversionError;
14422        fn try_from(
14423            value: ::std::string::String,
14424        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14425            value.parse()
14426        }
14427    }
14428
14429    ///`OptionsBlocksRequest`
14430    ///
14431    /// <details><summary>JSON schema</summary>
14432    ///
14433    /// ```json
14434    ///{
14435    ///  "type": "object",
14436    ///  "properties": {
14437    ///    "_async": {
14438    ///      "description": "Run the command asynchronously. Returns a job id
14439    /// immediately.",
14440    ///      "type": "boolean"
14441    ///    },
14442    ///    "_group": {
14443    ///      "description": "Assign the request to a custom stats group.",
14444    ///      "type": "string"
14445    ///    }
14446    ///  }
14447    ///}
14448    /// ```
14449    /// </details>
14450    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14451    pub struct OptionsBlocksRequest {
14452        ///Run the command asynchronously. Returns a job id immediately.
14453        #[serde(
14454            rename = "_async",
14455            default,
14456            skip_serializing_if = "::std::option::Option::is_none"
14457        )]
14458        pub async_: ::std::option::Option<bool>,
14459        ///Assign the request to a custom stats group.
14460        #[serde(
14461            rename = "_group",
14462            default,
14463            skip_serializing_if = "::std::option::Option::is_none"
14464        )]
14465        pub group: ::std::option::Option<::std::string::String>,
14466    }
14467
14468    impl ::std::convert::From<&OptionsBlocksRequest> for OptionsBlocksRequest {
14469        fn from(value: &OptionsBlocksRequest) -> Self {
14470            value.clone()
14471        }
14472    }
14473
14474    impl ::std::default::Default for OptionsBlocksRequest {
14475        fn default() -> Self {
14476            Self {
14477                async_: Default::default(),
14478                group: Default::default(),
14479            }
14480        }
14481    }
14482
14483    ///`OptionsBlocksResponse`
14484    ///
14485    /// <details><summary>JSON schema</summary>
14486    ///
14487    /// ```json
14488    ///{
14489    ///  "type": "object",
14490    ///  "required": [
14491    ///    "options"
14492    ///  ],
14493    ///  "properties": {
14494    ///    "options": {
14495    ///      "type": "array",
14496    ///      "items": {
14497    ///        "type": "string"
14498    ///      }
14499    ///    }
14500    ///  }
14501    ///}
14502    /// ```
14503    /// </details>
14504    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14505    pub struct OptionsBlocksResponse {
14506        pub options: ::std::vec::Vec<::std::string::String>,
14507    }
14508
14509    impl ::std::convert::From<&OptionsBlocksResponse> for OptionsBlocksResponse {
14510        fn from(value: &OptionsBlocksResponse) -> Self {
14511            value.clone()
14512        }
14513    }
14514
14515    ///`OptionsGetPrefer`
14516    ///
14517    /// <details><summary>JSON schema</summary>
14518    ///
14519    /// ```json
14520    ///{
14521    ///  "type": "string",
14522    ///  "enum": [
14523    ///    "respond-async"
14524    ///  ]
14525    ///}
14526    /// ```
14527    /// </details>
14528    #[derive(
14529        :: serde :: Deserialize,
14530        :: serde :: Serialize,
14531        Clone,
14532        Copy,
14533        Debug,
14534        Eq,
14535        Hash,
14536        Ord,
14537        PartialEq,
14538        PartialOrd,
14539    )]
14540    pub enum OptionsGetPrefer {
14541        #[serde(rename = "respond-async")]
14542        RespondAsync,
14543    }
14544
14545    impl ::std::convert::From<&Self> for OptionsGetPrefer {
14546        fn from(value: &OptionsGetPrefer) -> Self {
14547            value.clone()
14548        }
14549    }
14550
14551    impl ::std::fmt::Display for OptionsGetPrefer {
14552        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14553            match *self {
14554                Self::RespondAsync => f.write_str("respond-async"),
14555            }
14556        }
14557    }
14558
14559    impl ::std::str::FromStr for OptionsGetPrefer {
14560        type Err = self::error::ConversionError;
14561        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14562            match value {
14563                "respond-async" => Ok(Self::RespondAsync),
14564                _ => Err("invalid value".into()),
14565            }
14566        }
14567    }
14568
14569    impl ::std::convert::TryFrom<&str> for OptionsGetPrefer {
14570        type Error = self::error::ConversionError;
14571        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
14572            value.parse()
14573        }
14574    }
14575
14576    impl ::std::convert::TryFrom<&::std::string::String> for OptionsGetPrefer {
14577        type Error = self::error::ConversionError;
14578        fn try_from(
14579            value: &::std::string::String,
14580        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14581            value.parse()
14582        }
14583    }
14584
14585    impl ::std::convert::TryFrom<::std::string::String> for OptionsGetPrefer {
14586        type Error = self::error::ConversionError;
14587        fn try_from(
14588            value: ::std::string::String,
14589        ) -> ::std::result::Result<Self, self::error::ConversionError> {
14590            value.parse()
14591        }
14592    }
14593
14594    ///`OptionsGetRequest`
14595    ///
14596    /// <details><summary>JSON schema</summary>
14597    ///
14598    /// ```json
14599    ///{
14600    ///  "type": "object",
14601    ///  "properties": {
14602    ///    "_async": {
14603    ///      "description": "Run the command asynchronously. Returns a job id
14604    /// immediately.",
14605    ///      "type": "boolean"
14606    ///    },
14607    ///    "_group": {
14608    ///      "description": "Assign the request to a custom stats group.",
14609    ///      "type": "string"
14610    ///    },
14611    ///    "blocks": {
14612    ///      "description": "Optional comma-separated list of option block names
14613    /// to return.",
14614    ///      "type": "string"
14615    ///    }
14616    ///  }
14617    ///}
14618    /// ```
14619    /// </details>
14620    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14621    pub struct OptionsGetRequest {
14622        ///Run the command asynchronously. Returns a job id immediately.
14623        #[serde(
14624            rename = "_async",
14625            default,
14626            skip_serializing_if = "::std::option::Option::is_none"
14627        )]
14628        pub async_: ::std::option::Option<bool>,
14629        ///Optional comma-separated list of option block names to return.
14630        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
14631        pub blocks: ::std::option::Option<::std::string::String>,
14632        ///Assign the request to a custom stats group.
14633        #[serde(
14634            rename = "_group",
14635            default,
14636            skip_serializing_if = "::std::option::Option::is_none"
14637        )]
14638        pub group: ::std::option::Option<::std::string::String>,
14639    }
14640
14641    impl ::std::convert::From<&OptionsGetRequest> for OptionsGetRequest {
14642        fn from(value: &OptionsGetRequest) -> Self {
14643            value.clone()
14644        }
14645    }
14646
14647    impl ::std::default::Default for OptionsGetRequest {
14648        fn default() -> Self {
14649            Self {
14650                async_: Default::default(),
14651                blocks: Default::default(),
14652                group: Default::default(),
14653            }
14654        }
14655    }
14656
14657    ///`OptionsGetResponse`
14658    ///
14659    /// <details><summary>JSON schema</summary>
14660    ///
14661    /// ```json
14662    ///{
14663    ///  "type": "object",
14664    ///  "required": [
14665    ///    "dlna",
14666    ///    "filter",
14667    ///    "ftp",
14668    ///    "http",
14669    ///    "log",
14670    ///    "main",
14671    ///    "mount",
14672    ///    "nfs",
14673    ///    "proxy",
14674    ///    "rc",
14675    ///    "restic",
14676    ///    "s3",
14677    ///    "sftp",
14678    ///    "vfs",
14679    ///    "webdav"
14680    ///  ],
14681    ///  "properties": {
14682    ///    "dlna": {
14683    ///      "type": "object",
14684    ///      "additionalProperties": true
14685    ///    },
14686    ///    "filter": {
14687    ///      "type": "object",
14688    ///      "additionalProperties": true
14689    ///    },
14690    ///    "ftp": {
14691    ///      "type": "object",
14692    ///      "additionalProperties": true
14693    ///    },
14694    ///    "http": {
14695    ///      "type": "object",
14696    ///      "additionalProperties": true
14697    ///    },
14698    ///    "log": {
14699    ///      "type": "object",
14700    ///      "additionalProperties": true
14701    ///    },
14702    ///    "main": {
14703    ///      "type": "object",
14704    ///      "additionalProperties": true
14705    ///    },
14706    ///    "mount": {
14707    ///      "type": "object",
14708    ///      "additionalProperties": true
14709    ///    },
14710    ///    "nfs": {
14711    ///      "type": "object",
14712    ///      "additionalProperties": true
14713    ///    },
14714    ///    "proxy": {
14715    ///      "type": "object",
14716    ///      "additionalProperties": true
14717    ///    },
14718    ///    "rc": {
14719    ///      "type": "object",
14720    ///      "additionalProperties": true
14721    ///    },
14722    ///    "restic": {
14723    ///      "type": "object",
14724    ///      "additionalProperties": true
14725    ///    },
14726    ///    "s3": {
14727    ///      "type": "object",
14728    ///      "additionalProperties": true
14729    ///    },
14730    ///    "sftp": {
14731    ///      "type": "object",
14732    ///      "additionalProperties": true
14733    ///    },
14734    ///    "vfs": {
14735    ///      "type": "object",
14736    ///      "additionalProperties": true
14737    ///    },
14738    ///    "webdav": {
14739    ///      "type": "object",
14740    ///      "additionalProperties": true
14741    ///    }
14742    ///  },
14743    ///  "additionalProperties": true
14744    ///}
14745    /// ```
14746    /// </details>
14747    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14748    pub struct OptionsGetResponse {
14749        pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14750        pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14751        pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14752        pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14753        pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14754        pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14755        pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14756        pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14757        pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14758        pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14759        pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14760        pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14761        pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14762        pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14763        pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
14764    }
14765
14766    impl ::std::convert::From<&OptionsGetResponse> for OptionsGetResponse {
14767        fn from(value: &OptionsGetResponse) -> Self {
14768            value.clone()
14769        }
14770    }
14771
14772    ///`OptionsInfoOption`
14773    ///
14774    /// <details><summary>JSON schema</summary>
14775    ///
14776    /// ```json
14777    ///{
14778    ///  "type": "object",
14779    ///  "required": [
14780    ///    "Advanced",
14781    ///    "Default",
14782    ///    "DefaultStr",
14783    ///    "Exclusive",
14784    ///    "FieldName",
14785    ///    "Help",
14786    ///    "Hide",
14787    ///    "IsPassword",
14788    ///    "Name",
14789    ///    "NoPrefix",
14790    ///    "Required",
14791    ///    "Sensitive",
14792    ///    "Type",
14793    ///    "Value",
14794    ///    "ValueStr"
14795    ///  ],
14796    ///  "properties": {
14797    ///    "Advanced": {
14798    ///      "type": "boolean"
14799    ///    },
14800    ///    "Default": {
14801    ///      "description": "Default value for this option.",
14802    ///      "anyOf": [
14803    ///        {
14804    ///          "type": "array",
14805    ///          "items": {
14806    ///            "type": "string"
14807    ///          }
14808    ///        },
14809    ///        {
14810    ///          "type": "boolean"
14811    ///        },
14812    ///        {
14813    ///          "type": "number"
14814    ///        },
14815    ///        {
14816    ///          "type": "string"
14817    ///        },
14818    ///        {
14819    ///          "type": "object",
14820    ///          "required": [
14821    ///            "Valid",
14822    ///            "Value"
14823    ///          ],
14824    ///          "properties": {
14825    ///            "Valid": {
14826    ///              "type": "boolean"
14827    ///            },
14828    ///            "Value": {
14829    ///              "type": "boolean"
14830    ///            }
14831    ///          },
14832    ///          "additionalProperties": false
14833    ///        }
14834    ///      ]
14835    ///    },
14836    ///    "DefaultStr": {
14837    ///      "type": "string"
14838    ///    },
14839    ///    "Examples": {
14840    ///      "type": "array",
14841    ///      "items": {
14842    ///        "$ref": "#/components/schemas/OptionsInfoOptionExample"
14843    ///      }
14844    ///    },
14845    ///    "Exclusive": {
14846    ///      "type": "boolean"
14847    ///    },
14848    ///    "FieldName": {
14849    ///      "type": "string"
14850    ///    },
14851    ///    "Groups": {
14852    ///      "type": "string"
14853    ///    },
14854    ///    "Help": {
14855    ///      "type": "string"
14856    ///    },
14857    ///    "Hide": {
14858    ///      "type": "integer"
14859    ///    },
14860    ///    "IsPassword": {
14861    ///      "type": "boolean"
14862    ///    },
14863    ///    "Name": {
14864    ///      "type": "string"
14865    ///    },
14866    ///    "NoPrefix": {
14867    ///      "type": "boolean"
14868    ///    },
14869    ///    "Required": {
14870    ///      "type": "boolean"
14871    ///    },
14872    ///    "Sensitive": {
14873    ///      "type": "boolean"
14874    ///    },
14875    ///    "ShortOpt": {
14876    ///      "type": "string"
14877    ///    },
14878    ///    "Type": {
14879    ///      "type": "string"
14880    ///    },
14881    ///    "Value": {
14882    ///      "description": "Current value of this option.",
14883    ///      "oneOf": [
14884    ///        {
14885    ///          "type": "null"
14886    ///        },
14887    ///        {
14888    ///          "anyOf": [
14889    ///            {
14890    ///              "type": "array",
14891    ///              "items": {
14892    ///                "type": "string"
14893    ///              }
14894    ///            },
14895    ///            {
14896    ///              "type": "boolean"
14897    ///            },
14898    ///            {
14899    ///              "type": "number"
14900    ///            },
14901    ///            {
14902    ///              "type": "string"
14903    ///            },
14904    ///            {
14905    ///              "type": "object",
14906    ///              "required": [
14907    ///                "Valid",
14908    ///                "Value"
14909    ///              ],
14910    ///              "properties": {
14911    ///                "Valid": {
14912    ///                  "type": "boolean"
14913    ///                },
14914    ///                "Value": {
14915    ///                  "type": "boolean"
14916    ///                }
14917    ///              },
14918    ///              "additionalProperties": false
14919    ///            }
14920    ///          ]
14921    ///        }
14922    ///      ]
14923    ///    },
14924    ///    "ValueStr": {
14925    ///      "type": "string"
14926    ///    }
14927    ///  },
14928    ///  "additionalProperties": true
14929    ///}
14930    /// ```
14931    /// </details>
14932    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
14933    pub struct OptionsInfoOption {
14934        #[serde(rename = "Advanced")]
14935        pub advanced: bool,
14936        ///Default value for this option.
14937        #[serde(rename = "Default")]
14938        pub default: OptionsInfoOptionDefault,
14939        #[serde(rename = "DefaultStr")]
14940        pub default_str: ::std::string::String,
14941        #[serde(
14942            rename = "Examples",
14943            default,
14944            skip_serializing_if = "::std::vec::Vec::is_empty"
14945        )]
14946        pub examples: ::std::vec::Vec<OptionsInfoOptionExample>,
14947        #[serde(rename = "Exclusive")]
14948        pub exclusive: bool,
14949        #[serde(rename = "FieldName")]
14950        pub field_name: ::std::string::String,
14951        #[serde(
14952            rename = "Groups",
14953            default,
14954            skip_serializing_if = "::std::option::Option::is_none"
14955        )]
14956        pub groups: ::std::option::Option<::std::string::String>,
14957        #[serde(rename = "Help")]
14958        pub help: ::std::string::String,
14959        #[serde(rename = "Hide")]
14960        pub hide: i64,
14961        #[serde(rename = "IsPassword")]
14962        pub is_password: bool,
14963        #[serde(rename = "Name")]
14964        pub name: ::std::string::String,
14965        #[serde(rename = "NoPrefix")]
14966        pub no_prefix: bool,
14967        #[serde(rename = "Required")]
14968        pub required: bool,
14969        #[serde(rename = "Sensitive")]
14970        pub sensitive: bool,
14971        #[serde(
14972            rename = "ShortOpt",
14973            default,
14974            skip_serializing_if = "::std::option::Option::is_none"
14975        )]
14976        pub short_opt: ::std::option::Option<::std::string::String>,
14977        #[serde(rename = "Type")]
14978        pub type_: ::std::string::String,
14979        ///Current value of this option.
14980        #[serde(rename = "Value")]
14981        pub value: ::std::option::Option<OptionsInfoOptionValue>,
14982        #[serde(rename = "ValueStr")]
14983        pub value_str: ::std::string::String,
14984    }
14985
14986    impl ::std::convert::From<&OptionsInfoOption> for OptionsInfoOption {
14987        fn from(value: &OptionsInfoOption) -> Self {
14988            value.clone()
14989        }
14990    }
14991
14992    ///Default value for this option.
14993    ///
14994    /// <details><summary>JSON schema</summary>
14995    ///
14996    /// ```json
14997    ///{
14998    ///  "description": "Default value for this option.",
14999    ///  "anyOf": [
15000    ///    {
15001    ///      "type": "array",
15002    ///      "items": {
15003    ///        "type": "string"
15004    ///      }
15005    ///    },
15006    ///    {
15007    ///      "type": "boolean"
15008    ///    },
15009    ///    {
15010    ///      "type": "number"
15011    ///    },
15012    ///    {
15013    ///      "type": "string"
15014    ///    },
15015    ///    {
15016    ///      "type": "object",
15017    ///      "required": [
15018    ///        "Valid",
15019    ///        "Value"
15020    ///      ],
15021    ///      "properties": {
15022    ///        "Valid": {
15023    ///          "type": "boolean"
15024    ///        },
15025    ///        "Value": {
15026    ///          "type": "boolean"
15027    ///        }
15028    ///      },
15029    ///      "additionalProperties": false
15030    ///    }
15031    ///  ]
15032    ///}
15033    /// ```
15034    /// </details>
15035    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15036    #[serde(untagged, deny_unknown_fields)]
15037    pub enum OptionsInfoOptionDefault {
15038        Variant0(::std::vec::Vec<::std::string::String>),
15039        Variant1(bool),
15040        Variant2(f64),
15041        Variant3(::std::string::String),
15042        Variant4 {
15043            #[serde(rename = "Valid")]
15044            valid: bool,
15045            #[serde(rename = "Value")]
15046            value: bool,
15047        },
15048    }
15049
15050    impl ::std::convert::From<&Self> for OptionsInfoOptionDefault {
15051        fn from(value: &OptionsInfoOptionDefault) -> Self {
15052            value.clone()
15053        }
15054    }
15055
15056    impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionDefault {
15057        fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
15058            Self::Variant0(value)
15059        }
15060    }
15061
15062    impl ::std::convert::From<bool> for OptionsInfoOptionDefault {
15063        fn from(value: bool) -> Self {
15064            Self::Variant1(value)
15065        }
15066    }
15067
15068    impl ::std::convert::From<f64> for OptionsInfoOptionDefault {
15069        fn from(value: f64) -> Self {
15070            Self::Variant2(value)
15071        }
15072    }
15073
15074    ///`OptionsInfoOptionExample`
15075    ///
15076    /// <details><summary>JSON schema</summary>
15077    ///
15078    /// ```json
15079    ///{
15080    ///  "type": "object",
15081    ///  "required": [
15082    ///    "Help",
15083    ///    "Value"
15084    ///  ],
15085    ///  "properties": {
15086    ///    "Help": {
15087    ///      "type": "string"
15088    ///    },
15089    ///    "Value": {
15090    ///      "type": "string"
15091    ///    }
15092    ///  },
15093    ///  "additionalProperties": true
15094    ///}
15095    /// ```
15096    /// </details>
15097    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15098    pub struct OptionsInfoOptionExample {
15099        #[serde(rename = "Help")]
15100        pub help: ::std::string::String,
15101        #[serde(rename = "Value")]
15102        pub value: ::std::string::String,
15103    }
15104
15105    impl ::std::convert::From<&OptionsInfoOptionExample> for OptionsInfoOptionExample {
15106        fn from(value: &OptionsInfoOptionExample) -> Self {
15107            value.clone()
15108        }
15109    }
15110
15111    ///`OptionsInfoOptionValue`
15112    ///
15113    /// <details><summary>JSON schema</summary>
15114    ///
15115    /// ```json
15116    ///{
15117    ///  "anyOf": [
15118    ///    {
15119    ///      "type": "array",
15120    ///      "items": {
15121    ///        "type": "string"
15122    ///      }
15123    ///    },
15124    ///    {
15125    ///      "type": "boolean"
15126    ///    },
15127    ///    {
15128    ///      "type": "number"
15129    ///    },
15130    ///    {
15131    ///      "type": "string"
15132    ///    },
15133    ///    {
15134    ///      "type": "object",
15135    ///      "required": [
15136    ///        "Valid",
15137    ///        "Value"
15138    ///      ],
15139    ///      "properties": {
15140    ///        "Valid": {
15141    ///          "type": "boolean"
15142    ///        },
15143    ///        "Value": {
15144    ///          "type": "boolean"
15145    ///        }
15146    ///      },
15147    ///      "additionalProperties": false
15148    ///    }
15149    ///  ]
15150    ///}
15151    /// ```
15152    /// </details>
15153    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15154    #[serde(untagged, deny_unknown_fields)]
15155    pub enum OptionsInfoOptionValue {
15156        Variant0(::std::vec::Vec<::std::string::String>),
15157        Variant1(bool),
15158        Variant2(f64),
15159        Variant3(::std::string::String),
15160        Variant4 {
15161            #[serde(rename = "Valid")]
15162            valid: bool,
15163            #[serde(rename = "Value")]
15164            value: bool,
15165        },
15166    }
15167
15168    impl ::std::convert::From<&Self> for OptionsInfoOptionValue {
15169        fn from(value: &OptionsInfoOptionValue) -> Self {
15170            value.clone()
15171        }
15172    }
15173
15174    impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionValue {
15175        fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
15176            Self::Variant0(value)
15177        }
15178    }
15179
15180    impl ::std::convert::From<bool> for OptionsInfoOptionValue {
15181        fn from(value: bool) -> Self {
15182            Self::Variant1(value)
15183        }
15184    }
15185
15186    impl ::std::convert::From<f64> for OptionsInfoOptionValue {
15187        fn from(value: f64) -> Self {
15188            Self::Variant2(value)
15189        }
15190    }
15191
15192    ///`OptionsInfoPrefer`
15193    ///
15194    /// <details><summary>JSON schema</summary>
15195    ///
15196    /// ```json
15197    ///{
15198    ///  "type": "string",
15199    ///  "enum": [
15200    ///    "respond-async"
15201    ///  ]
15202    ///}
15203    /// ```
15204    /// </details>
15205    #[derive(
15206        :: serde :: Deserialize,
15207        :: serde :: Serialize,
15208        Clone,
15209        Copy,
15210        Debug,
15211        Eq,
15212        Hash,
15213        Ord,
15214        PartialEq,
15215        PartialOrd,
15216    )]
15217    pub enum OptionsInfoPrefer {
15218        #[serde(rename = "respond-async")]
15219        RespondAsync,
15220    }
15221
15222    impl ::std::convert::From<&Self> for OptionsInfoPrefer {
15223        fn from(value: &OptionsInfoPrefer) -> Self {
15224            value.clone()
15225        }
15226    }
15227
15228    impl ::std::fmt::Display for OptionsInfoPrefer {
15229        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15230            match *self {
15231                Self::RespondAsync => f.write_str("respond-async"),
15232            }
15233        }
15234    }
15235
15236    impl ::std::str::FromStr for OptionsInfoPrefer {
15237        type Err = self::error::ConversionError;
15238        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
15239            match value {
15240                "respond-async" => Ok(Self::RespondAsync),
15241                _ => Err("invalid value".into()),
15242            }
15243        }
15244    }
15245
15246    impl ::std::convert::TryFrom<&str> for OptionsInfoPrefer {
15247        type Error = self::error::ConversionError;
15248        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
15249            value.parse()
15250        }
15251    }
15252
15253    impl ::std::convert::TryFrom<&::std::string::String> for OptionsInfoPrefer {
15254        type Error = self::error::ConversionError;
15255        fn try_from(
15256            value: &::std::string::String,
15257        ) -> ::std::result::Result<Self, self::error::ConversionError> {
15258            value.parse()
15259        }
15260    }
15261
15262    impl ::std::convert::TryFrom<::std::string::String> for OptionsInfoPrefer {
15263        type Error = self::error::ConversionError;
15264        fn try_from(
15265            value: ::std::string::String,
15266        ) -> ::std::result::Result<Self, self::error::ConversionError> {
15267            value.parse()
15268        }
15269    }
15270
15271    ///`OptionsInfoRequest`
15272    ///
15273    /// <details><summary>JSON schema</summary>
15274    ///
15275    /// ```json
15276    ///{
15277    ///  "type": "object",
15278    ///  "properties": {
15279    ///    "_async": {
15280    ///      "description": "Run the command asynchronously. Returns a job id
15281    /// immediately.",
15282    ///      "type": "boolean"
15283    ///    },
15284    ///    "_group": {
15285    ///      "description": "Assign the request to a custom stats group.",
15286    ///      "type": "string"
15287    ///    },
15288    ///    "blocks": {
15289    ///      "description": "Optional comma-separated list of option block names
15290    /// to describe.",
15291    ///      "type": "string"
15292    ///    }
15293    ///  }
15294    ///}
15295    /// ```
15296    /// </details>
15297    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15298    pub struct OptionsInfoRequest {
15299        ///Run the command asynchronously. Returns a job id immediately.
15300        #[serde(
15301            rename = "_async",
15302            default,
15303            skip_serializing_if = "::std::option::Option::is_none"
15304        )]
15305        pub async_: ::std::option::Option<bool>,
15306        ///Optional comma-separated list of option block names to describe.
15307        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
15308        pub blocks: ::std::option::Option<::std::string::String>,
15309        ///Assign the request to a custom stats group.
15310        #[serde(
15311            rename = "_group",
15312            default,
15313            skip_serializing_if = "::std::option::Option::is_none"
15314        )]
15315        pub group: ::std::option::Option<::std::string::String>,
15316    }
15317
15318    impl ::std::convert::From<&OptionsInfoRequest> for OptionsInfoRequest {
15319        fn from(value: &OptionsInfoRequest) -> Self {
15320            value.clone()
15321        }
15322    }
15323
15324    impl ::std::default::Default for OptionsInfoRequest {
15325        fn default() -> Self {
15326            Self {
15327                async_: Default::default(),
15328                blocks: Default::default(),
15329                group: Default::default(),
15330            }
15331        }
15332    }
15333
15334    ///`OptionsInfoResponse`
15335    ///
15336    /// <details><summary>JSON schema</summary>
15337    ///
15338    /// ```json
15339    ///{
15340    ///  "type": "object",
15341    ///  "properties": {
15342    ///    "dlna": {
15343    ///      "type": "array",
15344    ///      "items": {
15345    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15346    ///      }
15347    ///    },
15348    ///    "filter": {
15349    ///      "type": "array",
15350    ///      "items": {
15351    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15352    ///      }
15353    ///    },
15354    ///    "ftp": {
15355    ///      "type": "array",
15356    ///      "items": {
15357    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15358    ///      }
15359    ///    },
15360    ///    "http": {
15361    ///      "type": "array",
15362    ///      "items": {
15363    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15364    ///      }
15365    ///    },
15366    ///    "log": {
15367    ///      "type": "array",
15368    ///      "items": {
15369    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15370    ///      }
15371    ///    },
15372    ///    "main": {
15373    ///      "type": "array",
15374    ///      "items": {
15375    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15376    ///      }
15377    ///    },
15378    ///    "mount": {
15379    ///      "type": "array",
15380    ///      "items": {
15381    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15382    ///      }
15383    ///    },
15384    ///    "nfs": {
15385    ///      "type": "array",
15386    ///      "items": {
15387    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15388    ///      }
15389    ///    },
15390    ///    "proxy": {
15391    ///      "type": "array",
15392    ///      "items": {
15393    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15394    ///      }
15395    ///    },
15396    ///    "rc": {
15397    ///      "type": "array",
15398    ///      "items": {
15399    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15400    ///      }
15401    ///    },
15402    ///    "restic": {
15403    ///      "type": "array",
15404    ///      "items": {
15405    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15406    ///      }
15407    ///    },
15408    ///    "s3": {
15409    ///      "type": "array",
15410    ///      "items": {
15411    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15412    ///      }
15413    ///    },
15414    ///    "sftp": {
15415    ///      "type": "array",
15416    ///      "items": {
15417    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15418    ///      }
15419    ///    },
15420    ///    "vfs": {
15421    ///      "type": "array",
15422    ///      "items": {
15423    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15424    ///      }
15425    ///    },
15426    ///    "webdav": {
15427    ///      "type": "array",
15428    ///      "items": {
15429    ///        "$ref": "#/components/schemas/OptionsInfoOption"
15430    ///      }
15431    ///    }
15432    ///  },
15433    ///  "additionalProperties": {
15434    ///    "type": "array",
15435    ///    "items": {
15436    ///      "$ref": "#/components/schemas/OptionsInfoOption"
15437    ///    }
15438    ///  }
15439    ///}
15440    /// ```
15441    /// </details>
15442    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15443    pub struct OptionsInfoResponse {
15444        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15445        pub dlna: ::std::vec::Vec<OptionsInfoOption>,
15446        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15447        pub filter: ::std::vec::Vec<OptionsInfoOption>,
15448        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15449        pub ftp: ::std::vec::Vec<OptionsInfoOption>,
15450        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15451        pub http: ::std::vec::Vec<OptionsInfoOption>,
15452        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15453        pub log: ::std::vec::Vec<OptionsInfoOption>,
15454        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15455        pub main: ::std::vec::Vec<OptionsInfoOption>,
15456        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15457        pub mount: ::std::vec::Vec<OptionsInfoOption>,
15458        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15459        pub nfs: ::std::vec::Vec<OptionsInfoOption>,
15460        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15461        pub proxy: ::std::vec::Vec<OptionsInfoOption>,
15462        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15463        pub rc: ::std::vec::Vec<OptionsInfoOption>,
15464        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15465        pub restic: ::std::vec::Vec<OptionsInfoOption>,
15466        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15467        pub s3: ::std::vec::Vec<OptionsInfoOption>,
15468        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15469        pub sftp: ::std::vec::Vec<OptionsInfoOption>,
15470        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15471        pub vfs: ::std::vec::Vec<OptionsInfoOption>,
15472        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
15473        pub webdav: ::std::vec::Vec<OptionsInfoOption>,
15474        #[serde(flatten)]
15475        pub extra:
15476            ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<OptionsInfoOption>>,
15477    }
15478
15479    impl ::std::convert::From<&OptionsInfoResponse> for OptionsInfoResponse {
15480        fn from(value: &OptionsInfoResponse) -> Self {
15481            value.clone()
15482        }
15483    }
15484
15485    ///`OptionsLocalPrefer`
15486    ///
15487    /// <details><summary>JSON schema</summary>
15488    ///
15489    /// ```json
15490    ///{
15491    ///  "type": "string",
15492    ///  "enum": [
15493    ///    "respond-async"
15494    ///  ]
15495    ///}
15496    /// ```
15497    /// </details>
15498    #[derive(
15499        :: serde :: Deserialize,
15500        :: serde :: Serialize,
15501        Clone,
15502        Copy,
15503        Debug,
15504        Eq,
15505        Hash,
15506        Ord,
15507        PartialEq,
15508        PartialOrd,
15509    )]
15510    pub enum OptionsLocalPrefer {
15511        #[serde(rename = "respond-async")]
15512        RespondAsync,
15513    }
15514
15515    impl ::std::convert::From<&Self> for OptionsLocalPrefer {
15516        fn from(value: &OptionsLocalPrefer) -> Self {
15517            value.clone()
15518        }
15519    }
15520
15521    impl ::std::fmt::Display for OptionsLocalPrefer {
15522        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15523            match *self {
15524                Self::RespondAsync => f.write_str("respond-async"),
15525            }
15526        }
15527    }
15528
15529    impl ::std::str::FromStr for OptionsLocalPrefer {
15530        type Err = self::error::ConversionError;
15531        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
15532            match value {
15533                "respond-async" => Ok(Self::RespondAsync),
15534                _ => Err("invalid value".into()),
15535            }
15536        }
15537    }
15538
15539    impl ::std::convert::TryFrom<&str> for OptionsLocalPrefer {
15540        type Error = self::error::ConversionError;
15541        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
15542            value.parse()
15543        }
15544    }
15545
15546    impl ::std::convert::TryFrom<&::std::string::String> for OptionsLocalPrefer {
15547        type Error = self::error::ConversionError;
15548        fn try_from(
15549            value: &::std::string::String,
15550        ) -> ::std::result::Result<Self, self::error::ConversionError> {
15551            value.parse()
15552        }
15553    }
15554
15555    impl ::std::convert::TryFrom<::std::string::String> for OptionsLocalPrefer {
15556        type Error = self::error::ConversionError;
15557        fn try_from(
15558            value: ::std::string::String,
15559        ) -> ::std::result::Result<Self, self::error::ConversionError> {
15560            value.parse()
15561        }
15562    }
15563
15564    ///`OptionsLocalRequest`
15565    ///
15566    /// <details><summary>JSON schema</summary>
15567    ///
15568    /// ```json
15569    ///{
15570    ///  "type": "object",
15571    ///  "properties": {
15572    ///    "_async": {
15573    ///      "description": "Run the command asynchronously. Returns a job id
15574    /// immediately.",
15575    ///      "type": "boolean"
15576    ///    },
15577    ///    "_config": {
15578    ///      "description": "JSON encoded config overrides applied for this call
15579    /// only.",
15580    ///      "type": "string"
15581    ///    },
15582    ///    "_filter": {
15583    ///      "description": "JSON encoded filter overrides applied for this call
15584    /// only.",
15585    ///      "type": "string"
15586    ///    },
15587    ///    "_group": {
15588    ///      "description": "Assign the request to a custom stats group.",
15589    ///      "type": "string"
15590    ///    }
15591    ///  }
15592    ///}
15593    /// ```
15594    /// </details>
15595    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
15596    pub struct OptionsLocalRequest {
15597        ///Run the command asynchronously. Returns a job id immediately.
15598        #[serde(
15599            rename = "_async",
15600            default,
15601            skip_serializing_if = "::std::option::Option::is_none"
15602        )]
15603        pub async_: ::std::option::Option<bool>,
15604        ///JSON encoded config overrides applied for this call only.
15605        #[serde(
15606            rename = "_config",
15607            default,
15608            skip_serializing_if = "::std::option::Option::is_none"
15609        )]
15610        pub config: ::std::option::Option<::std::string::String>,
15611        ///JSON encoded filter overrides applied for this call only.
15612        #[serde(
15613            rename = "_filter",
15614            default,
15615            skip_serializing_if = "::std::option::Option::is_none"
15616        )]
15617        pub filter: ::std::option::Option<::std::string::String>,
15618        ///Assign the request to a custom stats group.
15619        #[serde(
15620            rename = "_group",
15621            default,
15622            skip_serializing_if = "::std::option::Option::is_none"
15623        )]
15624        pub group: ::std::option::Option<::std::string::String>,
15625    }
15626
15627    impl ::std::convert::From<&OptionsLocalRequest> for OptionsLocalRequest {
15628        fn from(value: &OptionsLocalRequest) -> Self {
15629            value.clone()
15630        }
15631    }
15632
15633    impl ::std::default::Default for OptionsLocalRequest {
15634        fn default() -> Self {
15635            Self {
15636                async_: Default::default(),
15637                config: Default::default(),
15638                filter: Default::default(),
15639                group: Default::default(),
15640            }
15641        }
15642    }
15643
15644    ///`OptionsLocalResponse`
15645    ///
15646    /// <details><summary>JSON schema</summary>
15647    ///
15648    /// ```json
15649    ///{
15650    ///  "type": "object",
15651    ///  "required": [
15652    ///    "config",
15653    ///    "filter"
15654    ///  ],
15655    ///  "properties": {
15656    ///    "config": {
15657    ///      "type": "object",
15658    ///      "required": [
15659    ///        "AskPassword",
15660    ///        "AutoConfirm",
15661    ///        "BackupDir",
15662    ///        "BindAddr",
15663    ///        "BufferSize",
15664    ///        "BwLimit",
15665    ///        "BwLimitFile",
15666    ///        "CaCert",
15667    ///        "CheckFirst",
15668    ///        "CheckSum",
15669    ///        "Checkers",
15670    ///        "ClientCert",
15671    ///        "ClientKey",
15672    ///        "CompareDest",
15673    ///        "ConnectTimeout",
15674    ///        "Cookie",
15675    ///        "CopyDest",
15676    ///        "CutoffMode",
15677    ///        "DataRateUnit",
15678    ///        "DefaultTime",
15679    ///        "DeleteMode",
15680    ///        "DisableFeatures",
15681    ///        "DisableHTTP2",
15682    ///        "DisableHTTPKeepAlives",
15683    ///        "DownloadHeaders",
15684    ///        "DryRun",
15685    ///        "Dump",
15686    ///        "ErrorOnNoTransfer",
15687    ///        "ExpectContinueTimeout",
15688    ///        "FixCase",
15689    ///        "FsCacheExpireDuration",
15690    ///        "FsCacheExpireInterval",
15691    ///        "Headers",
15692    ///        "HumanReadable",
15693    ///        "IgnoreCaseSync",
15694    ///        "IgnoreChecksum",
15695    ///        "IgnoreErrors",
15696    ///        "IgnoreExisting",
15697    ///        "IgnoreSize",
15698    ///        "IgnoreTimes",
15699    ///        "Immutable",
15700    ///        "Inplace",
15701    ///        "InsecureSkipVerify",
15702    ///        "Interactive",
15703    ///        "KvLockTime",
15704    ///        "Links",
15705    ///        "LogLevel",
15706    ///        "LowLevelRetries",
15707    ///        "MaxBacklog",
15708    ///        "MaxBufferMemory",
15709    ///        "MaxDelete",
15710    ///        "MaxDeleteSize",
15711    ///        "MaxDepth",
15712    ///        "MaxDuration",
15713    ///        "MaxStatsGroups",
15714    ///        "MaxTransfer",
15715    ///        "Metadata",
15716    ///        "MetadataMapper",
15717    ///        "MetadataSet",
15718    ///        "ModifyWindow",
15719    ///        "MultiThreadChunkSize",
15720    ///        "MultiThreadCutoff",
15721    ///        "MultiThreadSet",
15722    ///        "MultiThreadStreams",
15723    ///        "MultiThreadWriteBufferSize",
15724    ///        "NoCheckDest",
15725    ///        "NoConsole",
15726    ///        "NoGzip",
15727    ///        "NoTraverse",
15728    ///        "NoUnicodeNormalization",
15729    ///        "NoUpdateDirModTime",
15730    ///        "NoUpdateModTime",
15731    ///        "OrderBy",
15732    ///        "PartialSuffix",
15733    ///        "PasswordCommand",
15734    ///        "Progress",
15735    ///        "ProgressTerminalTitle",
15736    ///        "RefreshTimes",
15737    ///        "Retries",
15738    ///        "RetriesInterval",
15739    ///        "ServerSideAcrossConfigs",
15740    ///        "SizeOnly",
15741    ///        "StatsFileNameLength",
15742    ///        "StatsLogLevel",
15743    ///        "StatsOneLine",
15744    ///        "StatsOneLineDate",
15745    ///        "StatsOneLineDateFormat",
15746    ///        "StreamingUploadCutoff",
15747    ///        "Suffix",
15748    ///        "SuffixKeepExtension",
15749    ///        "TPSLimit",
15750    ///        "TPSLimitBurst",
15751    ///        "TerminalColorMode",
15752    ///        "Timeout",
15753    ///        "TrackRenames",
15754    ///        "TrackRenamesStrategy",
15755    ///        "TrafficClass",
15756    ///        "Transfers",
15757    ///        "UpdateOlder",
15758    ///        "UploadHeaders",
15759    ///        "UseJSONLog",
15760    ///        "UseListR",
15761    ///        "UseMmap",
15762    ///        "UseServerModTime",
15763    ///        "UserAgent"
15764    ///      ],
15765    ///      "properties": {
15766    ///        "AskPassword": {
15767    ///          "type": "boolean"
15768    ///        },
15769    ///        "AutoConfirm": {
15770    ///          "type": "boolean"
15771    ///        },
15772    ///        "BackupDir": {
15773    ///          "type": "string"
15774    ///        },
15775    ///        "BindAddr": {
15776    ///          "type": "string"
15777    ///        },
15778    ///        "BufferSize": {
15779    ///          "type": "number"
15780    ///        },
15781    ///        "BwLimit": {
15782    ///          "type": "string"
15783    ///        },
15784    ///        "BwLimitFile": {
15785    ///          "type": "string"
15786    ///        },
15787    ///        "CaCert": {
15788    ///          "type": "array",
15789    ///          "items": {
15790    ///            "type": "string"
15791    ///          }
15792    ///        },
15793    ///        "CheckFirst": {
15794    ///          "type": "boolean"
15795    ///        },
15796    ///        "CheckSum": {
15797    ///          "type": "boolean"
15798    ///        },
15799    ///        "Checkers": {
15800    ///          "type": "number"
15801    ///        },
15802    ///        "ClientCert": {
15803    ///          "type": "string"
15804    ///        },
15805    ///        "ClientKey": {
15806    ///          "type": "string"
15807    ///        },
15808    ///        "CompareDest": {
15809    ///          "type": "array",
15810    ///          "items": {
15811    ///            "type": "string"
15812    ///          }
15813    ///        },
15814    ///        "ConnectTimeout": {
15815    ///          "type": "number"
15816    ///        },
15817    ///        "Cookie": {
15818    ///          "type": "boolean"
15819    ///        },
15820    ///        "CopyDest": {
15821    ///          "type": "array",
15822    ///          "items": {
15823    ///            "type": "string"
15824    ///          }
15825    ///        },
15826    ///        "CutoffMode": {
15827    ///          "type": "string"
15828    ///        },
15829    ///        "DataRateUnit": {
15830    ///          "type": "string"
15831    ///        },
15832    ///        "DefaultTime": {
15833    ///          "type": "string"
15834    ///        },
15835    ///        "DeleteMode": {
15836    ///          "type": "number"
15837    ///        },
15838    ///        "DisableFeatures": {
15839    ///          "type": [
15840    ///            "string",
15841    ///            "null"
15842    ///          ]
15843    ///        },
15844    ///        "DisableHTTP2": {
15845    ///          "type": "boolean"
15846    ///        },
15847    ///        "DisableHTTPKeepAlives": {
15848    ///          "type": "boolean"
15849    ///        },
15850    ///        "DownloadHeaders": {
15851    ///          "type": [
15852    ///            "string",
15853    ///            "null"
15854    ///          ]
15855    ///        },
15856    ///        "DryRun": {
15857    ///          "type": "boolean"
15858    ///        },
15859    ///        "Dump": {
15860    ///          "type": "string"
15861    ///        },
15862    ///        "ErrorOnNoTransfer": {
15863    ///          "type": "boolean"
15864    ///        },
15865    ///        "ExpectContinueTimeout": {
15866    ///          "type": "number"
15867    ///        },
15868    ///        "FixCase": {
15869    ///          "type": "boolean"
15870    ///        },
15871    ///        "FsCacheExpireDuration": {
15872    ///          "type": "number"
15873    ///        },
15874    ///        "FsCacheExpireInterval": {
15875    ///          "type": "number"
15876    ///        },
15877    ///        "Headers": {
15878    ///          "type": [
15879    ///            "string",
15880    ///            "null"
15881    ///          ]
15882    ///        },
15883    ///        "HumanReadable": {
15884    ///          "type": "boolean"
15885    ///        },
15886    ///        "IgnoreCaseSync": {
15887    ///          "type": "boolean"
15888    ///        },
15889    ///        "IgnoreChecksum": {
15890    ///          "type": "boolean"
15891    ///        },
15892    ///        "IgnoreErrors": {
15893    ///          "type": "boolean"
15894    ///        },
15895    ///        "IgnoreExisting": {
15896    ///          "type": "boolean"
15897    ///        },
15898    ///        "IgnoreSize": {
15899    ///          "type": "boolean"
15900    ///        },
15901    ///        "IgnoreTimes": {
15902    ///          "type": "boolean"
15903    ///        },
15904    ///        "Immutable": {
15905    ///          "type": "boolean"
15906    ///        },
15907    ///        "Inplace": {
15908    ///          "type": "boolean"
15909    ///        },
15910    ///        "InsecureSkipVerify": {
15911    ///          "type": "boolean"
15912    ///        },
15913    ///        "Interactive": {
15914    ///          "type": "boolean"
15915    ///        },
15916    ///        "KvLockTime": {
15917    ///          "type": "number"
15918    ///        },
15919    ///        "Links": {
15920    ///          "type": "boolean"
15921    ///        },
15922    ///        "LogLevel": {
15923    ///          "type": "string"
15924    ///        },
15925    ///        "LowLevelRetries": {
15926    ///          "type": "number"
15927    ///        },
15928    ///        "MaxBacklog": {
15929    ///          "type": "number"
15930    ///        },
15931    ///        "MaxBufferMemory": {
15932    ///          "type": "number"
15933    ///        },
15934    ///        "MaxDelete": {
15935    ///          "type": "number"
15936    ///        },
15937    ///        "MaxDeleteSize": {
15938    ///          "type": "number"
15939    ///        },
15940    ///        "MaxDepth": {
15941    ///          "type": "number"
15942    ///        },
15943    ///        "MaxDuration": {
15944    ///          "type": "number"
15945    ///        },
15946    ///        "MaxStatsGroups": {
15947    ///          "type": "number"
15948    ///        },
15949    ///        "MaxTransfer": {
15950    ///          "type": "number"
15951    ///        },
15952    ///        "Metadata": {
15953    ///          "type": "boolean"
15954    ///        },
15955    ///        "MetadataMapper": {
15956    ///          "type": [
15957    ///            "string",
15958    ///            "null"
15959    ///          ]
15960    ///        },
15961    ///        "MetadataSet": {
15962    ///          "type": [
15963    ///            "string",
15964    ///            "null"
15965    ///          ]
15966    ///        },
15967    ///        "ModifyWindow": {
15968    ///          "type": "number"
15969    ///        },
15970    ///        "MultiThreadChunkSize": {
15971    ///          "type": "number"
15972    ///        },
15973    ///        "MultiThreadCutoff": {
15974    ///          "type": "number"
15975    ///        },
15976    ///        "MultiThreadSet": {
15977    ///          "type": "boolean"
15978    ///        },
15979    ///        "MultiThreadStreams": {
15980    ///          "type": "number"
15981    ///        },
15982    ///        "MultiThreadWriteBufferSize": {
15983    ///          "type": "number"
15984    ///        },
15985    ///        "NoCheckDest": {
15986    ///          "type": "boolean"
15987    ///        },
15988    ///        "NoConsole": {
15989    ///          "type": "boolean"
15990    ///        },
15991    ///        "NoGzip": {
15992    ///          "type": "boolean"
15993    ///        },
15994    ///        "NoTraverse": {
15995    ///          "type": "boolean"
15996    ///        },
15997    ///        "NoUnicodeNormalization": {
15998    ///          "type": "boolean"
15999    ///        },
16000    ///        "NoUpdateDirModTime": {
16001    ///          "type": "boolean"
16002    ///        },
16003    ///        "NoUpdateModTime": {
16004    ///          "type": "boolean"
16005    ///        },
16006    ///        "OrderBy": {
16007    ///          "type": "string"
16008    ///        },
16009    ///        "PartialSuffix": {
16010    ///          "type": "string"
16011    ///        },
16012    ///        "PasswordCommand": {
16013    ///          "type": [
16014    ///            "string",
16015    ///            "null"
16016    ///          ]
16017    ///        },
16018    ///        "Progress": {
16019    ///          "type": "boolean"
16020    ///        },
16021    ///        "ProgressTerminalTitle": {
16022    ///          "type": "boolean"
16023    ///        },
16024    ///        "RefreshTimes": {
16025    ///          "type": "boolean"
16026    ///        },
16027    ///        "Retries": {
16028    ///          "type": "number"
16029    ///        },
16030    ///        "RetriesInterval": {
16031    ///          "type": "number"
16032    ///        },
16033    ///        "ServerSideAcrossConfigs": {
16034    ///          "type": "boolean"
16035    ///        },
16036    ///        "SizeOnly": {
16037    ///          "type": "boolean"
16038    ///        },
16039    ///        "StatsFileNameLength": {
16040    ///          "type": "number"
16041    ///        },
16042    ///        "StatsLogLevel": {
16043    ///          "type": "string"
16044    ///        },
16045    ///        "StatsOneLine": {
16046    ///          "type": "boolean"
16047    ///        },
16048    ///        "StatsOneLineDate": {
16049    ///          "type": "boolean"
16050    ///        },
16051    ///        "StatsOneLineDateFormat": {
16052    ///          "type": "string"
16053    ///        },
16054    ///        "StreamingUploadCutoff": {
16055    ///          "type": "number"
16056    ///        },
16057    ///        "Suffix": {
16058    ///          "type": "string"
16059    ///        },
16060    ///        "SuffixKeepExtension": {
16061    ///          "type": "boolean"
16062    ///        },
16063    ///        "TPSLimit": {
16064    ///          "type": "number"
16065    ///        },
16066    ///        "TPSLimitBurst": {
16067    ///          "type": "number"
16068    ///        },
16069    ///        "TerminalColorMode": {
16070    ///          "type": "string"
16071    ///        },
16072    ///        "Timeout": {
16073    ///          "type": "number"
16074    ///        },
16075    ///        "TrackRenames": {
16076    ///          "type": "boolean"
16077    ///        },
16078    ///        "TrackRenamesStrategy": {
16079    ///          "type": "string"
16080    ///        },
16081    ///        "TrafficClass": {
16082    ///          "type": "number"
16083    ///        },
16084    ///        "Transfers": {
16085    ///          "type": "number"
16086    ///        },
16087    ///        "UpdateOlder": {
16088    ///          "type": "boolean"
16089    ///        },
16090    ///        "UploadHeaders": {
16091    ///          "type": [
16092    ///            "string",
16093    ///            "null"
16094    ///          ]
16095    ///        },
16096    ///        "UseJSONLog": {
16097    ///          "type": "boolean"
16098    ///        },
16099    ///        "UseListR": {
16100    ///          "type": "boolean"
16101    ///        },
16102    ///        "UseMmap": {
16103    ///          "type": "boolean"
16104    ///        },
16105    ///        "UseServerModTime": {
16106    ///          "type": "boolean"
16107    ///        },
16108    ///        "UserAgent": {
16109    ///          "type": "string"
16110    ///        }
16111    ///      }
16112    ///    },
16113    ///    "filter": {
16114    ///      "type": "object",
16115    ///      "required": [
16116    ///        "DeleteExcluded",
16117    ///        "ExcludeFile",
16118    ///        "ExcludeFrom",
16119    ///        "ExcludeRule",
16120    ///        "FilesFrom",
16121    ///        "FilesFromRaw",
16122    ///        "FilterFrom",
16123    ///        "FilterRule",
16124    ///        "HashFilter",
16125    ///        "IgnoreCase",
16126    ///        "IncludeFrom",
16127    ///        "IncludeRule",
16128    ///        "MaxAge",
16129    ///        "MaxSize",
16130    ///        "MetaRules",
16131    ///        "MinAge",
16132    ///        "MinSize"
16133    ///      ],
16134    ///      "properties": {
16135    ///        "DeleteExcluded": {
16136    ///          "type": "boolean"
16137    ///        },
16138    ///        "ExcludeFile": {
16139    ///          "type": "array",
16140    ///          "items": {
16141    ///            "type": "string"
16142    ///          }
16143    ///        },
16144    ///        "ExcludeFrom": {
16145    ///          "type": "array",
16146    ///          "items": {
16147    ///            "type": "string"
16148    ///          }
16149    ///        },
16150    ///        "ExcludeRule": {
16151    ///          "type": "array",
16152    ///          "items": {
16153    ///            "type": "string"
16154    ///          }
16155    ///        },
16156    ///        "FilesFrom": {
16157    ///          "type": "array",
16158    ///          "items": {
16159    ///            "type": "string"
16160    ///          }
16161    ///        },
16162    ///        "FilesFromRaw": {
16163    ///          "type": "array",
16164    ///          "items": {
16165    ///            "type": "string"
16166    ///          }
16167    ///        },
16168    ///        "FilterFrom": {
16169    ///          "type": "array",
16170    ///          "items": {
16171    ///            "type": "string"
16172    ///          }
16173    ///        },
16174    ///        "FilterRule": {
16175    ///          "type": "array",
16176    ///          "items": {
16177    ///            "type": "string"
16178    ///          }
16179    ///        },
16180    ///        "HashFilter": {
16181    ///          "type": "string"
16182    ///        },
16183    ///        "IgnoreCase": {
16184    ///          "type": "boolean"
16185    ///        },
16186    ///        "IncludeFrom": {
16187    ///          "type": "array",
16188    ///          "items": {
16189    ///            "type": "string"
16190    ///          }
16191    ///        },
16192    ///        "IncludeRule": {
16193    ///          "type": "array",
16194    ///          "items": {
16195    ///            "type": "string"
16196    ///          }
16197    ///        },
16198    ///        "MaxAge": {
16199    ///          "type": "number"
16200    ///        },
16201    ///        "MaxSize": {
16202    ///          "type": "number"
16203    ///        },
16204    ///        "MetaRules": {
16205    ///          "type": "object",
16206    ///          "required": [
16207    ///            "ExcludeFrom",
16208    ///            "ExcludeRule",
16209    ///            "FilterFrom",
16210    ///            "FilterRule",
16211    ///            "IncludeFrom",
16212    ///            "IncludeRule"
16213    ///          ],
16214    ///          "properties": {
16215    ///            "ExcludeFrom": {
16216    ///              "type": "array",
16217    ///              "items": {
16218    ///                "type": "string"
16219    ///              }
16220    ///            },
16221    ///            "ExcludeRule": {
16222    ///              "type": "array",
16223    ///              "items": {
16224    ///                "type": "string"
16225    ///              }
16226    ///            },
16227    ///            "FilterFrom": {
16228    ///              "type": "array",
16229    ///              "items": {
16230    ///                "type": "string"
16231    ///              }
16232    ///            },
16233    ///            "FilterRule": {
16234    ///              "type": "array",
16235    ///              "items": {
16236    ///                "type": "string"
16237    ///              }
16238    ///            },
16239    ///            "IncludeFrom": {
16240    ///              "type": "array",
16241    ///              "items": {
16242    ///                "type": "string"
16243    ///              }
16244    ///            },
16245    ///            "IncludeRule": {
16246    ///              "type": "array",
16247    ///              "items": {
16248    ///                "type": "string"
16249    ///              }
16250    ///            }
16251    ///          }
16252    ///        },
16253    ///        "MinAge": {
16254    ///          "type": "number"
16255    ///        },
16256    ///        "MinSize": {
16257    ///          "type": "number"
16258    ///        }
16259    ///      }
16260    ///    }
16261    ///  }
16262    ///}
16263    /// ```
16264    /// </details>
16265    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
16266    pub struct OptionsLocalResponse {
16267        pub config: OptionsLocalResponseConfig,
16268        pub filter: OptionsLocalResponseFilter,
16269    }
16270
16271    impl ::std::convert::From<&OptionsLocalResponse> for OptionsLocalResponse {
16272        fn from(value: &OptionsLocalResponse) -> Self {
16273            value.clone()
16274        }
16275    }
16276
16277    ///`OptionsLocalResponseConfig`
16278    ///
16279    /// <details><summary>JSON schema</summary>
16280    ///
16281    /// ```json
16282    ///{
16283    ///  "type": "object",
16284    ///  "required": [
16285    ///    "AskPassword",
16286    ///    "AutoConfirm",
16287    ///    "BackupDir",
16288    ///    "BindAddr",
16289    ///    "BufferSize",
16290    ///    "BwLimit",
16291    ///    "BwLimitFile",
16292    ///    "CaCert",
16293    ///    "CheckFirst",
16294    ///    "CheckSum",
16295    ///    "Checkers",
16296    ///    "ClientCert",
16297    ///    "ClientKey",
16298    ///    "CompareDest",
16299    ///    "ConnectTimeout",
16300    ///    "Cookie",
16301    ///    "CopyDest",
16302    ///    "CutoffMode",
16303    ///    "DataRateUnit",
16304    ///    "DefaultTime",
16305    ///    "DeleteMode",
16306    ///    "DisableFeatures",
16307    ///    "DisableHTTP2",
16308    ///    "DisableHTTPKeepAlives",
16309    ///    "DownloadHeaders",
16310    ///    "DryRun",
16311    ///    "Dump",
16312    ///    "ErrorOnNoTransfer",
16313    ///    "ExpectContinueTimeout",
16314    ///    "FixCase",
16315    ///    "FsCacheExpireDuration",
16316    ///    "FsCacheExpireInterval",
16317    ///    "Headers",
16318    ///    "HumanReadable",
16319    ///    "IgnoreCaseSync",
16320    ///    "IgnoreChecksum",
16321    ///    "IgnoreErrors",
16322    ///    "IgnoreExisting",
16323    ///    "IgnoreSize",
16324    ///    "IgnoreTimes",
16325    ///    "Immutable",
16326    ///    "Inplace",
16327    ///    "InsecureSkipVerify",
16328    ///    "Interactive",
16329    ///    "KvLockTime",
16330    ///    "Links",
16331    ///    "LogLevel",
16332    ///    "LowLevelRetries",
16333    ///    "MaxBacklog",
16334    ///    "MaxBufferMemory",
16335    ///    "MaxDelete",
16336    ///    "MaxDeleteSize",
16337    ///    "MaxDepth",
16338    ///    "MaxDuration",
16339    ///    "MaxStatsGroups",
16340    ///    "MaxTransfer",
16341    ///    "Metadata",
16342    ///    "MetadataMapper",
16343    ///    "MetadataSet",
16344    ///    "ModifyWindow",
16345    ///    "MultiThreadChunkSize",
16346    ///    "MultiThreadCutoff",
16347    ///    "MultiThreadSet",
16348    ///    "MultiThreadStreams",
16349    ///    "MultiThreadWriteBufferSize",
16350    ///    "NoCheckDest",
16351    ///    "NoConsole",
16352    ///    "NoGzip",
16353    ///    "NoTraverse",
16354    ///    "NoUnicodeNormalization",
16355    ///    "NoUpdateDirModTime",
16356    ///    "NoUpdateModTime",
16357    ///    "OrderBy",
16358    ///    "PartialSuffix",
16359    ///    "PasswordCommand",
16360    ///    "Progress",
16361    ///    "ProgressTerminalTitle",
16362    ///    "RefreshTimes",
16363    ///    "Retries",
16364    ///    "RetriesInterval",
16365    ///    "ServerSideAcrossConfigs",
16366    ///    "SizeOnly",
16367    ///    "StatsFileNameLength",
16368    ///    "StatsLogLevel",
16369    ///    "StatsOneLine",
16370    ///    "StatsOneLineDate",
16371    ///    "StatsOneLineDateFormat",
16372    ///    "StreamingUploadCutoff",
16373    ///    "Suffix",
16374    ///    "SuffixKeepExtension",
16375    ///    "TPSLimit",
16376    ///    "TPSLimitBurst",
16377    ///    "TerminalColorMode",
16378    ///    "Timeout",
16379    ///    "TrackRenames",
16380    ///    "TrackRenamesStrategy",
16381    ///    "TrafficClass",
16382    ///    "Transfers",
16383    ///    "UpdateOlder",
16384    ///    "UploadHeaders",
16385    ///    "UseJSONLog",
16386    ///    "UseListR",
16387    ///    "UseMmap",
16388    ///    "UseServerModTime",
16389    ///    "UserAgent"
16390    ///  ],
16391    ///  "properties": {
16392    ///    "AskPassword": {
16393    ///      "type": "boolean"
16394    ///    },
16395    ///    "AutoConfirm": {
16396    ///      "type": "boolean"
16397    ///    },
16398    ///    "BackupDir": {
16399    ///      "type": "string"
16400    ///    },
16401    ///    "BindAddr": {
16402    ///      "type": "string"
16403    ///    },
16404    ///    "BufferSize": {
16405    ///      "type": "number"
16406    ///    },
16407    ///    "BwLimit": {
16408    ///      "type": "string"
16409    ///    },
16410    ///    "BwLimitFile": {
16411    ///      "type": "string"
16412    ///    },
16413    ///    "CaCert": {
16414    ///      "type": "array",
16415    ///      "items": {
16416    ///        "type": "string"
16417    ///      }
16418    ///    },
16419    ///    "CheckFirst": {
16420    ///      "type": "boolean"
16421    ///    },
16422    ///    "CheckSum": {
16423    ///      "type": "boolean"
16424    ///    },
16425    ///    "Checkers": {
16426    ///      "type": "number"
16427    ///    },
16428    ///    "ClientCert": {
16429    ///      "type": "string"
16430    ///    },
16431    ///    "ClientKey": {
16432    ///      "type": "string"
16433    ///    },
16434    ///    "CompareDest": {
16435    ///      "type": "array",
16436    ///      "items": {
16437    ///        "type": "string"
16438    ///      }
16439    ///    },
16440    ///    "ConnectTimeout": {
16441    ///      "type": "number"
16442    ///    },
16443    ///    "Cookie": {
16444    ///      "type": "boolean"
16445    ///    },
16446    ///    "CopyDest": {
16447    ///      "type": "array",
16448    ///      "items": {
16449    ///        "type": "string"
16450    ///      }
16451    ///    },
16452    ///    "CutoffMode": {
16453    ///      "type": "string"
16454    ///    },
16455    ///    "DataRateUnit": {
16456    ///      "type": "string"
16457    ///    },
16458    ///    "DefaultTime": {
16459    ///      "type": "string"
16460    ///    },
16461    ///    "DeleteMode": {
16462    ///      "type": "number"
16463    ///    },
16464    ///    "DisableFeatures": {
16465    ///      "type": [
16466    ///        "string",
16467    ///        "null"
16468    ///      ]
16469    ///    },
16470    ///    "DisableHTTP2": {
16471    ///      "type": "boolean"
16472    ///    },
16473    ///    "DisableHTTPKeepAlives": {
16474    ///      "type": "boolean"
16475    ///    },
16476    ///    "DownloadHeaders": {
16477    ///      "type": [
16478    ///        "string",
16479    ///        "null"
16480    ///      ]
16481    ///    },
16482    ///    "DryRun": {
16483    ///      "type": "boolean"
16484    ///    },
16485    ///    "Dump": {
16486    ///      "type": "string"
16487    ///    },
16488    ///    "ErrorOnNoTransfer": {
16489    ///      "type": "boolean"
16490    ///    },
16491    ///    "ExpectContinueTimeout": {
16492    ///      "type": "number"
16493    ///    },
16494    ///    "FixCase": {
16495    ///      "type": "boolean"
16496    ///    },
16497    ///    "FsCacheExpireDuration": {
16498    ///      "type": "number"
16499    ///    },
16500    ///    "FsCacheExpireInterval": {
16501    ///      "type": "number"
16502    ///    },
16503    ///    "Headers": {
16504    ///      "type": [
16505    ///        "string",
16506    ///        "null"
16507    ///      ]
16508    ///    },
16509    ///    "HumanReadable": {
16510    ///      "type": "boolean"
16511    ///    },
16512    ///    "IgnoreCaseSync": {
16513    ///      "type": "boolean"
16514    ///    },
16515    ///    "IgnoreChecksum": {
16516    ///      "type": "boolean"
16517    ///    },
16518    ///    "IgnoreErrors": {
16519    ///      "type": "boolean"
16520    ///    },
16521    ///    "IgnoreExisting": {
16522    ///      "type": "boolean"
16523    ///    },
16524    ///    "IgnoreSize": {
16525    ///      "type": "boolean"
16526    ///    },
16527    ///    "IgnoreTimes": {
16528    ///      "type": "boolean"
16529    ///    },
16530    ///    "Immutable": {
16531    ///      "type": "boolean"
16532    ///    },
16533    ///    "Inplace": {
16534    ///      "type": "boolean"
16535    ///    },
16536    ///    "InsecureSkipVerify": {
16537    ///      "type": "boolean"
16538    ///    },
16539    ///    "Interactive": {
16540    ///      "type": "boolean"
16541    ///    },
16542    ///    "KvLockTime": {
16543    ///      "type": "number"
16544    ///    },
16545    ///    "Links": {
16546    ///      "type": "boolean"
16547    ///    },
16548    ///    "LogLevel": {
16549    ///      "type": "string"
16550    ///    },
16551    ///    "LowLevelRetries": {
16552    ///      "type": "number"
16553    ///    },
16554    ///    "MaxBacklog": {
16555    ///      "type": "number"
16556    ///    },
16557    ///    "MaxBufferMemory": {
16558    ///      "type": "number"
16559    ///    },
16560    ///    "MaxDelete": {
16561    ///      "type": "number"
16562    ///    },
16563    ///    "MaxDeleteSize": {
16564    ///      "type": "number"
16565    ///    },
16566    ///    "MaxDepth": {
16567    ///      "type": "number"
16568    ///    },
16569    ///    "MaxDuration": {
16570    ///      "type": "number"
16571    ///    },
16572    ///    "MaxStatsGroups": {
16573    ///      "type": "number"
16574    ///    },
16575    ///    "MaxTransfer": {
16576    ///      "type": "number"
16577    ///    },
16578    ///    "Metadata": {
16579    ///      "type": "boolean"
16580    ///    },
16581    ///    "MetadataMapper": {
16582    ///      "type": [
16583    ///        "string",
16584    ///        "null"
16585    ///      ]
16586    ///    },
16587    ///    "MetadataSet": {
16588    ///      "type": [
16589    ///        "string",
16590    ///        "null"
16591    ///      ]
16592    ///    },
16593    ///    "ModifyWindow": {
16594    ///      "type": "number"
16595    ///    },
16596    ///    "MultiThreadChunkSize": {
16597    ///      "type": "number"
16598    ///    },
16599    ///    "MultiThreadCutoff": {
16600    ///      "type": "number"
16601    ///    },
16602    ///    "MultiThreadSet": {
16603    ///      "type": "boolean"
16604    ///    },
16605    ///    "MultiThreadStreams": {
16606    ///      "type": "number"
16607    ///    },
16608    ///    "MultiThreadWriteBufferSize": {
16609    ///      "type": "number"
16610    ///    },
16611    ///    "NoCheckDest": {
16612    ///      "type": "boolean"
16613    ///    },
16614    ///    "NoConsole": {
16615    ///      "type": "boolean"
16616    ///    },
16617    ///    "NoGzip": {
16618    ///      "type": "boolean"
16619    ///    },
16620    ///    "NoTraverse": {
16621    ///      "type": "boolean"
16622    ///    },
16623    ///    "NoUnicodeNormalization": {
16624    ///      "type": "boolean"
16625    ///    },
16626    ///    "NoUpdateDirModTime": {
16627    ///      "type": "boolean"
16628    ///    },
16629    ///    "NoUpdateModTime": {
16630    ///      "type": "boolean"
16631    ///    },
16632    ///    "OrderBy": {
16633    ///      "type": "string"
16634    ///    },
16635    ///    "PartialSuffix": {
16636    ///      "type": "string"
16637    ///    },
16638    ///    "PasswordCommand": {
16639    ///      "type": [
16640    ///        "string",
16641    ///        "null"
16642    ///      ]
16643    ///    },
16644    ///    "Progress": {
16645    ///      "type": "boolean"
16646    ///    },
16647    ///    "ProgressTerminalTitle": {
16648    ///      "type": "boolean"
16649    ///    },
16650    ///    "RefreshTimes": {
16651    ///      "type": "boolean"
16652    ///    },
16653    ///    "Retries": {
16654    ///      "type": "number"
16655    ///    },
16656    ///    "RetriesInterval": {
16657    ///      "type": "number"
16658    ///    },
16659    ///    "ServerSideAcrossConfigs": {
16660    ///      "type": "boolean"
16661    ///    },
16662    ///    "SizeOnly": {
16663    ///      "type": "boolean"
16664    ///    },
16665    ///    "StatsFileNameLength": {
16666    ///      "type": "number"
16667    ///    },
16668    ///    "StatsLogLevel": {
16669    ///      "type": "string"
16670    ///    },
16671    ///    "StatsOneLine": {
16672    ///      "type": "boolean"
16673    ///    },
16674    ///    "StatsOneLineDate": {
16675    ///      "type": "boolean"
16676    ///    },
16677    ///    "StatsOneLineDateFormat": {
16678    ///      "type": "string"
16679    ///    },
16680    ///    "StreamingUploadCutoff": {
16681    ///      "type": "number"
16682    ///    },
16683    ///    "Suffix": {
16684    ///      "type": "string"
16685    ///    },
16686    ///    "SuffixKeepExtension": {
16687    ///      "type": "boolean"
16688    ///    },
16689    ///    "TPSLimit": {
16690    ///      "type": "number"
16691    ///    },
16692    ///    "TPSLimitBurst": {
16693    ///      "type": "number"
16694    ///    },
16695    ///    "TerminalColorMode": {
16696    ///      "type": "string"
16697    ///    },
16698    ///    "Timeout": {
16699    ///      "type": "number"
16700    ///    },
16701    ///    "TrackRenames": {
16702    ///      "type": "boolean"
16703    ///    },
16704    ///    "TrackRenamesStrategy": {
16705    ///      "type": "string"
16706    ///    },
16707    ///    "TrafficClass": {
16708    ///      "type": "number"
16709    ///    },
16710    ///    "Transfers": {
16711    ///      "type": "number"
16712    ///    },
16713    ///    "UpdateOlder": {
16714    ///      "type": "boolean"
16715    ///    },
16716    ///    "UploadHeaders": {
16717    ///      "type": [
16718    ///        "string",
16719    ///        "null"
16720    ///      ]
16721    ///    },
16722    ///    "UseJSONLog": {
16723    ///      "type": "boolean"
16724    ///    },
16725    ///    "UseListR": {
16726    ///      "type": "boolean"
16727    ///    },
16728    ///    "UseMmap": {
16729    ///      "type": "boolean"
16730    ///    },
16731    ///    "UseServerModTime": {
16732    ///      "type": "boolean"
16733    ///    },
16734    ///    "UserAgent": {
16735    ///      "type": "string"
16736    ///    }
16737    ///  }
16738    ///}
16739    /// ```
16740    /// </details>
16741    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
16742    pub struct OptionsLocalResponseConfig {
16743        #[serde(rename = "AskPassword")]
16744        pub ask_password: bool,
16745        #[serde(rename = "AutoConfirm")]
16746        pub auto_confirm: bool,
16747        #[serde(rename = "BackupDir")]
16748        pub backup_dir: ::std::string::String,
16749        #[serde(rename = "BindAddr")]
16750        pub bind_addr: ::std::string::String,
16751        #[serde(rename = "BufferSize")]
16752        pub buffer_size: f64,
16753        #[serde(rename = "BwLimit")]
16754        pub bw_limit: ::std::string::String,
16755        #[serde(rename = "BwLimitFile")]
16756        pub bw_limit_file: ::std::string::String,
16757        #[serde(rename = "CaCert")]
16758        pub ca_cert: ::std::vec::Vec<::std::string::String>,
16759        #[serde(rename = "CheckFirst")]
16760        pub check_first: bool,
16761        #[serde(rename = "CheckSum")]
16762        pub check_sum: bool,
16763        #[serde(rename = "Checkers")]
16764        pub checkers: f64,
16765        #[serde(rename = "ClientCert")]
16766        pub client_cert: ::std::string::String,
16767        #[serde(rename = "ClientKey")]
16768        pub client_key: ::std::string::String,
16769        #[serde(rename = "CompareDest")]
16770        pub compare_dest: ::std::vec::Vec<::std::string::String>,
16771        #[serde(rename = "ConnectTimeout")]
16772        pub connect_timeout: f64,
16773        #[serde(rename = "Cookie")]
16774        pub cookie: bool,
16775        #[serde(rename = "CopyDest")]
16776        pub copy_dest: ::std::vec::Vec<::std::string::String>,
16777        #[serde(rename = "CutoffMode")]
16778        pub cutoff_mode: ::std::string::String,
16779        #[serde(rename = "DataRateUnit")]
16780        pub data_rate_unit: ::std::string::String,
16781        #[serde(rename = "DefaultTime")]
16782        pub default_time: ::std::string::String,
16783        #[serde(rename = "DeleteMode")]
16784        pub delete_mode: f64,
16785        #[serde(rename = "DisableFeatures")]
16786        pub disable_features: ::std::option::Option<::std::string::String>,
16787        #[serde(rename = "DisableHTTP2")]
16788        pub disable_http2: bool,
16789        #[serde(rename = "DisableHTTPKeepAlives")]
16790        pub disable_http_keep_alives: bool,
16791        #[serde(rename = "DownloadHeaders")]
16792        pub download_headers: ::std::option::Option<::std::string::String>,
16793        #[serde(rename = "DryRun")]
16794        pub dry_run: bool,
16795        #[serde(rename = "Dump")]
16796        pub dump: ::std::string::String,
16797        #[serde(rename = "ErrorOnNoTransfer")]
16798        pub error_on_no_transfer: bool,
16799        #[serde(rename = "ExpectContinueTimeout")]
16800        pub expect_continue_timeout: f64,
16801        #[serde(rename = "FixCase")]
16802        pub fix_case: bool,
16803        #[serde(rename = "FsCacheExpireDuration")]
16804        pub fs_cache_expire_duration: f64,
16805        #[serde(rename = "FsCacheExpireInterval")]
16806        pub fs_cache_expire_interval: f64,
16807        #[serde(rename = "Headers")]
16808        pub headers: ::std::option::Option<::std::string::String>,
16809        #[serde(rename = "HumanReadable")]
16810        pub human_readable: bool,
16811        #[serde(rename = "IgnoreCaseSync")]
16812        pub ignore_case_sync: bool,
16813        #[serde(rename = "IgnoreChecksum")]
16814        pub ignore_checksum: bool,
16815        #[serde(rename = "IgnoreErrors")]
16816        pub ignore_errors: bool,
16817        #[serde(rename = "IgnoreExisting")]
16818        pub ignore_existing: bool,
16819        #[serde(rename = "IgnoreSize")]
16820        pub ignore_size: bool,
16821        #[serde(rename = "IgnoreTimes")]
16822        pub ignore_times: bool,
16823        #[serde(rename = "Immutable")]
16824        pub immutable: bool,
16825        #[serde(rename = "Inplace")]
16826        pub inplace: bool,
16827        #[serde(rename = "InsecureSkipVerify")]
16828        pub insecure_skip_verify: bool,
16829        #[serde(rename = "Interactive")]
16830        pub interactive: bool,
16831        #[serde(rename = "KvLockTime")]
16832        pub kv_lock_time: f64,
16833        #[serde(rename = "Links")]
16834        pub links: bool,
16835        #[serde(rename = "LogLevel")]
16836        pub log_level: ::std::string::String,
16837        #[serde(rename = "LowLevelRetries")]
16838        pub low_level_retries: f64,
16839        #[serde(rename = "MaxBacklog")]
16840        pub max_backlog: f64,
16841        #[serde(rename = "MaxBufferMemory")]
16842        pub max_buffer_memory: f64,
16843        #[serde(rename = "MaxDelete")]
16844        pub max_delete: f64,
16845        #[serde(rename = "MaxDeleteSize")]
16846        pub max_delete_size: f64,
16847        #[serde(rename = "MaxDepth")]
16848        pub max_depth: f64,
16849        #[serde(rename = "MaxDuration")]
16850        pub max_duration: f64,
16851        #[serde(rename = "MaxStatsGroups")]
16852        pub max_stats_groups: f64,
16853        #[serde(rename = "MaxTransfer")]
16854        pub max_transfer: f64,
16855        #[serde(rename = "Metadata")]
16856        pub metadata: bool,
16857        #[serde(rename = "MetadataMapper")]
16858        pub metadata_mapper: ::std::option::Option<::std::string::String>,
16859        #[serde(rename = "MetadataSet")]
16860        pub metadata_set: ::std::option::Option<::std::string::String>,
16861        #[serde(rename = "ModifyWindow")]
16862        pub modify_window: f64,
16863        #[serde(rename = "MultiThreadChunkSize")]
16864        pub multi_thread_chunk_size: f64,
16865        #[serde(rename = "MultiThreadCutoff")]
16866        pub multi_thread_cutoff: f64,
16867        #[serde(rename = "MultiThreadSet")]
16868        pub multi_thread_set: bool,
16869        #[serde(rename = "MultiThreadStreams")]
16870        pub multi_thread_streams: f64,
16871        #[serde(rename = "MultiThreadWriteBufferSize")]
16872        pub multi_thread_write_buffer_size: f64,
16873        #[serde(rename = "NoCheckDest")]
16874        pub no_check_dest: bool,
16875        #[serde(rename = "NoConsole")]
16876        pub no_console: bool,
16877        #[serde(rename = "NoGzip")]
16878        pub no_gzip: bool,
16879        #[serde(rename = "NoTraverse")]
16880        pub no_traverse: bool,
16881        #[serde(rename = "NoUnicodeNormalization")]
16882        pub no_unicode_normalization: bool,
16883        #[serde(rename = "NoUpdateDirModTime")]
16884        pub no_update_dir_mod_time: bool,
16885        #[serde(rename = "NoUpdateModTime")]
16886        pub no_update_mod_time: bool,
16887        #[serde(rename = "OrderBy")]
16888        pub order_by: ::std::string::String,
16889        #[serde(rename = "PartialSuffix")]
16890        pub partial_suffix: ::std::string::String,
16891        #[serde(rename = "PasswordCommand")]
16892        pub password_command: ::std::option::Option<::std::string::String>,
16893        #[serde(rename = "Progress")]
16894        pub progress: bool,
16895        #[serde(rename = "ProgressTerminalTitle")]
16896        pub progress_terminal_title: bool,
16897        #[serde(rename = "RefreshTimes")]
16898        pub refresh_times: bool,
16899        #[serde(rename = "Retries")]
16900        pub retries: f64,
16901        #[serde(rename = "RetriesInterval")]
16902        pub retries_interval: f64,
16903        #[serde(rename = "ServerSideAcrossConfigs")]
16904        pub server_side_across_configs: bool,
16905        #[serde(rename = "SizeOnly")]
16906        pub size_only: bool,
16907        #[serde(rename = "StatsFileNameLength")]
16908        pub stats_file_name_length: f64,
16909        #[serde(rename = "StatsLogLevel")]
16910        pub stats_log_level: ::std::string::String,
16911        #[serde(rename = "StatsOneLine")]
16912        pub stats_one_line: bool,
16913        #[serde(rename = "StatsOneLineDate")]
16914        pub stats_one_line_date: bool,
16915        #[serde(rename = "StatsOneLineDateFormat")]
16916        pub stats_one_line_date_format: ::std::string::String,
16917        #[serde(rename = "StreamingUploadCutoff")]
16918        pub streaming_upload_cutoff: f64,
16919        #[serde(rename = "Suffix")]
16920        pub suffix: ::std::string::String,
16921        #[serde(rename = "SuffixKeepExtension")]
16922        pub suffix_keep_extension: bool,
16923        #[serde(rename = "TerminalColorMode")]
16924        pub terminal_color_mode: ::std::string::String,
16925        #[serde(rename = "Timeout")]
16926        pub timeout: f64,
16927        #[serde(rename = "TPSLimit")]
16928        pub tps_limit: f64,
16929        #[serde(rename = "TPSLimitBurst")]
16930        pub tps_limit_burst: f64,
16931        #[serde(rename = "TrackRenames")]
16932        pub track_renames: bool,
16933        #[serde(rename = "TrackRenamesStrategy")]
16934        pub track_renames_strategy: ::std::string::String,
16935        #[serde(rename = "TrafficClass")]
16936        pub traffic_class: f64,
16937        #[serde(rename = "Transfers")]
16938        pub transfers: f64,
16939        #[serde(rename = "UpdateOlder")]
16940        pub update_older: bool,
16941        #[serde(rename = "UploadHeaders")]
16942        pub upload_headers: ::std::option::Option<::std::string::String>,
16943        #[serde(rename = "UseJSONLog")]
16944        pub use_json_log: bool,
16945        #[serde(rename = "UseListR")]
16946        pub use_list_r: bool,
16947        #[serde(rename = "UseMmap")]
16948        pub use_mmap: bool,
16949        #[serde(rename = "UseServerModTime")]
16950        pub use_server_mod_time: bool,
16951        #[serde(rename = "UserAgent")]
16952        pub user_agent: ::std::string::String,
16953    }
16954
16955    impl ::std::convert::From<&OptionsLocalResponseConfig> for OptionsLocalResponseConfig {
16956        fn from(value: &OptionsLocalResponseConfig) -> Self {
16957            value.clone()
16958        }
16959    }
16960
16961    ///`OptionsLocalResponseFilter`
16962    ///
16963    /// <details><summary>JSON schema</summary>
16964    ///
16965    /// ```json
16966    ///{
16967    ///  "type": "object",
16968    ///  "required": [
16969    ///    "DeleteExcluded",
16970    ///    "ExcludeFile",
16971    ///    "ExcludeFrom",
16972    ///    "ExcludeRule",
16973    ///    "FilesFrom",
16974    ///    "FilesFromRaw",
16975    ///    "FilterFrom",
16976    ///    "FilterRule",
16977    ///    "HashFilter",
16978    ///    "IgnoreCase",
16979    ///    "IncludeFrom",
16980    ///    "IncludeRule",
16981    ///    "MaxAge",
16982    ///    "MaxSize",
16983    ///    "MetaRules",
16984    ///    "MinAge",
16985    ///    "MinSize"
16986    ///  ],
16987    ///  "properties": {
16988    ///    "DeleteExcluded": {
16989    ///      "type": "boolean"
16990    ///    },
16991    ///    "ExcludeFile": {
16992    ///      "type": "array",
16993    ///      "items": {
16994    ///        "type": "string"
16995    ///      }
16996    ///    },
16997    ///    "ExcludeFrom": {
16998    ///      "type": "array",
16999    ///      "items": {
17000    ///        "type": "string"
17001    ///      }
17002    ///    },
17003    ///    "ExcludeRule": {
17004    ///      "type": "array",
17005    ///      "items": {
17006    ///        "type": "string"
17007    ///      }
17008    ///    },
17009    ///    "FilesFrom": {
17010    ///      "type": "array",
17011    ///      "items": {
17012    ///        "type": "string"
17013    ///      }
17014    ///    },
17015    ///    "FilesFromRaw": {
17016    ///      "type": "array",
17017    ///      "items": {
17018    ///        "type": "string"
17019    ///      }
17020    ///    },
17021    ///    "FilterFrom": {
17022    ///      "type": "array",
17023    ///      "items": {
17024    ///        "type": "string"
17025    ///      }
17026    ///    },
17027    ///    "FilterRule": {
17028    ///      "type": "array",
17029    ///      "items": {
17030    ///        "type": "string"
17031    ///      }
17032    ///    },
17033    ///    "HashFilter": {
17034    ///      "type": "string"
17035    ///    },
17036    ///    "IgnoreCase": {
17037    ///      "type": "boolean"
17038    ///    },
17039    ///    "IncludeFrom": {
17040    ///      "type": "array",
17041    ///      "items": {
17042    ///        "type": "string"
17043    ///      }
17044    ///    },
17045    ///    "IncludeRule": {
17046    ///      "type": "array",
17047    ///      "items": {
17048    ///        "type": "string"
17049    ///      }
17050    ///    },
17051    ///    "MaxAge": {
17052    ///      "type": "number"
17053    ///    },
17054    ///    "MaxSize": {
17055    ///      "type": "number"
17056    ///    },
17057    ///    "MetaRules": {
17058    ///      "type": "object",
17059    ///      "required": [
17060    ///        "ExcludeFrom",
17061    ///        "ExcludeRule",
17062    ///        "FilterFrom",
17063    ///        "FilterRule",
17064    ///        "IncludeFrom",
17065    ///        "IncludeRule"
17066    ///      ],
17067    ///      "properties": {
17068    ///        "ExcludeFrom": {
17069    ///          "type": "array",
17070    ///          "items": {
17071    ///            "type": "string"
17072    ///          }
17073    ///        },
17074    ///        "ExcludeRule": {
17075    ///          "type": "array",
17076    ///          "items": {
17077    ///            "type": "string"
17078    ///          }
17079    ///        },
17080    ///        "FilterFrom": {
17081    ///          "type": "array",
17082    ///          "items": {
17083    ///            "type": "string"
17084    ///          }
17085    ///        },
17086    ///        "FilterRule": {
17087    ///          "type": "array",
17088    ///          "items": {
17089    ///            "type": "string"
17090    ///          }
17091    ///        },
17092    ///        "IncludeFrom": {
17093    ///          "type": "array",
17094    ///          "items": {
17095    ///            "type": "string"
17096    ///          }
17097    ///        },
17098    ///        "IncludeRule": {
17099    ///          "type": "array",
17100    ///          "items": {
17101    ///            "type": "string"
17102    ///          }
17103    ///        }
17104    ///      }
17105    ///    },
17106    ///    "MinAge": {
17107    ///      "type": "number"
17108    ///    },
17109    ///    "MinSize": {
17110    ///      "type": "number"
17111    ///    }
17112    ///  }
17113    ///}
17114    /// ```
17115    /// </details>
17116    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17117    pub struct OptionsLocalResponseFilter {
17118        #[serde(rename = "DeleteExcluded")]
17119        pub delete_excluded: bool,
17120        #[serde(rename = "ExcludeFile")]
17121        pub exclude_file: ::std::vec::Vec<::std::string::String>,
17122        #[serde(rename = "ExcludeFrom")]
17123        pub exclude_from: ::std::vec::Vec<::std::string::String>,
17124        #[serde(rename = "ExcludeRule")]
17125        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
17126        #[serde(rename = "FilesFrom")]
17127        pub files_from: ::std::vec::Vec<::std::string::String>,
17128        #[serde(rename = "FilesFromRaw")]
17129        pub files_from_raw: ::std::vec::Vec<::std::string::String>,
17130        #[serde(rename = "FilterFrom")]
17131        pub filter_from: ::std::vec::Vec<::std::string::String>,
17132        #[serde(rename = "FilterRule")]
17133        pub filter_rule: ::std::vec::Vec<::std::string::String>,
17134        #[serde(rename = "HashFilter")]
17135        pub hash_filter: ::std::string::String,
17136        #[serde(rename = "IgnoreCase")]
17137        pub ignore_case: bool,
17138        #[serde(rename = "IncludeFrom")]
17139        pub include_from: ::std::vec::Vec<::std::string::String>,
17140        #[serde(rename = "IncludeRule")]
17141        pub include_rule: ::std::vec::Vec<::std::string::String>,
17142        #[serde(rename = "MaxAge")]
17143        pub max_age: f64,
17144        #[serde(rename = "MaxSize")]
17145        pub max_size: f64,
17146        #[serde(rename = "MetaRules")]
17147        pub meta_rules: OptionsLocalResponseFilterMetaRules,
17148        #[serde(rename = "MinAge")]
17149        pub min_age: f64,
17150        #[serde(rename = "MinSize")]
17151        pub min_size: f64,
17152    }
17153
17154    impl ::std::convert::From<&OptionsLocalResponseFilter> for OptionsLocalResponseFilter {
17155        fn from(value: &OptionsLocalResponseFilter) -> Self {
17156            value.clone()
17157        }
17158    }
17159
17160    ///`OptionsLocalResponseFilterMetaRules`
17161    ///
17162    /// <details><summary>JSON schema</summary>
17163    ///
17164    /// ```json
17165    ///{
17166    ///  "type": "object",
17167    ///  "required": [
17168    ///    "ExcludeFrom",
17169    ///    "ExcludeRule",
17170    ///    "FilterFrom",
17171    ///    "FilterRule",
17172    ///    "IncludeFrom",
17173    ///    "IncludeRule"
17174    ///  ],
17175    ///  "properties": {
17176    ///    "ExcludeFrom": {
17177    ///      "type": "array",
17178    ///      "items": {
17179    ///        "type": "string"
17180    ///      }
17181    ///    },
17182    ///    "ExcludeRule": {
17183    ///      "type": "array",
17184    ///      "items": {
17185    ///        "type": "string"
17186    ///      }
17187    ///    },
17188    ///    "FilterFrom": {
17189    ///      "type": "array",
17190    ///      "items": {
17191    ///        "type": "string"
17192    ///      }
17193    ///    },
17194    ///    "FilterRule": {
17195    ///      "type": "array",
17196    ///      "items": {
17197    ///        "type": "string"
17198    ///      }
17199    ///    },
17200    ///    "IncludeFrom": {
17201    ///      "type": "array",
17202    ///      "items": {
17203    ///        "type": "string"
17204    ///      }
17205    ///    },
17206    ///    "IncludeRule": {
17207    ///      "type": "array",
17208    ///      "items": {
17209    ///        "type": "string"
17210    ///      }
17211    ///    }
17212    ///  }
17213    ///}
17214    /// ```
17215    /// </details>
17216    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17217    pub struct OptionsLocalResponseFilterMetaRules {
17218        #[serde(rename = "ExcludeFrom")]
17219        pub exclude_from: ::std::vec::Vec<::std::string::String>,
17220        #[serde(rename = "ExcludeRule")]
17221        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
17222        #[serde(rename = "FilterFrom")]
17223        pub filter_from: ::std::vec::Vec<::std::string::String>,
17224        #[serde(rename = "FilterRule")]
17225        pub filter_rule: ::std::vec::Vec<::std::string::String>,
17226        #[serde(rename = "IncludeFrom")]
17227        pub include_from: ::std::vec::Vec<::std::string::String>,
17228        #[serde(rename = "IncludeRule")]
17229        pub include_rule: ::std::vec::Vec<::std::string::String>,
17230    }
17231
17232    impl ::std::convert::From<&OptionsLocalResponseFilterMetaRules>
17233        for OptionsLocalResponseFilterMetaRules
17234    {
17235        fn from(value: &OptionsLocalResponseFilterMetaRules) -> Self {
17236            value.clone()
17237        }
17238    }
17239
17240    ///`OptionsSetPrefer`
17241    ///
17242    /// <details><summary>JSON schema</summary>
17243    ///
17244    /// ```json
17245    ///{
17246    ///  "type": "string",
17247    ///  "enum": [
17248    ///    "respond-async"
17249    ///  ]
17250    ///}
17251    /// ```
17252    /// </details>
17253    #[derive(
17254        :: serde :: Deserialize,
17255        :: serde :: Serialize,
17256        Clone,
17257        Copy,
17258        Debug,
17259        Eq,
17260        Hash,
17261        Ord,
17262        PartialEq,
17263        PartialOrd,
17264    )]
17265    pub enum OptionsSetPrefer {
17266        #[serde(rename = "respond-async")]
17267        RespondAsync,
17268    }
17269
17270    impl ::std::convert::From<&Self> for OptionsSetPrefer {
17271        fn from(value: &OptionsSetPrefer) -> Self {
17272            value.clone()
17273        }
17274    }
17275
17276    impl ::std::fmt::Display for OptionsSetPrefer {
17277        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17278            match *self {
17279                Self::RespondAsync => f.write_str("respond-async"),
17280            }
17281        }
17282    }
17283
17284    impl ::std::str::FromStr for OptionsSetPrefer {
17285        type Err = self::error::ConversionError;
17286        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17287            match value {
17288                "respond-async" => Ok(Self::RespondAsync),
17289                _ => Err("invalid value".into()),
17290            }
17291        }
17292    }
17293
17294    impl ::std::convert::TryFrom<&str> for OptionsSetPrefer {
17295        type Error = self::error::ConversionError;
17296        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17297            value.parse()
17298        }
17299    }
17300
17301    impl ::std::convert::TryFrom<&::std::string::String> for OptionsSetPrefer {
17302        type Error = self::error::ConversionError;
17303        fn try_from(
17304            value: &::std::string::String,
17305        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17306            value.parse()
17307        }
17308    }
17309
17310    impl ::std::convert::TryFrom<::std::string::String> for OptionsSetPrefer {
17311        type Error = self::error::ConversionError;
17312        fn try_from(
17313            value: ::std::string::String,
17314        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17315            value.parse()
17316        }
17317    }
17318
17319    ///`OptionsSetRequest`
17320    ///
17321    /// <details><summary>JSON schema</summary>
17322    ///
17323    /// ```json
17324    ///{
17325    ///  "type": "object",
17326    ///  "properties": {
17327    ///    "_async": {
17328    ///      "description": "Run the command asynchronously. Returns a job id
17329    /// immediately.",
17330    ///      "type": "boolean"
17331    ///    },
17332    ///    "_group": {
17333    ///      "description": "Assign the request to a custom stats group.",
17334    ///      "type": "string"
17335    ///    },
17336    ///    "dlna": {
17337    ///      "description": "Overrides for the `dlna` option block.",
17338    ///      "type": "object",
17339    ///      "additionalProperties": true
17340    ///    },
17341    ///    "filter": {
17342    ///      "description": "Overrides for the `filter` option block.",
17343    ///      "type": "object",
17344    ///      "additionalProperties": true
17345    ///    },
17346    ///    "ftp": {
17347    ///      "description": "Overrides for the `ftp` option block.",
17348    ///      "type": "object",
17349    ///      "additionalProperties": true
17350    ///    },
17351    ///    "http": {
17352    ///      "description": "Overrides for the `http` option block.",
17353    ///      "type": "object",
17354    ///      "additionalProperties": true
17355    ///    },
17356    ///    "log": {
17357    ///      "description": "Overrides for the `log` option block.",
17358    ///      "type": "object",
17359    ///      "additionalProperties": true
17360    ///    },
17361    ///    "main": {
17362    ///      "description": "Overrides for the `main` option block.",
17363    ///      "type": "object",
17364    ///      "additionalProperties": true
17365    ///    },
17366    ///    "mount": {
17367    ///      "description": "Overrides for the `mount` option block.",
17368    ///      "type": "object",
17369    ///      "additionalProperties": true
17370    ///    },
17371    ///    "nfs": {
17372    ///      "description": "Overrides for the `nfs` option block.",
17373    ///      "type": "object",
17374    ///      "additionalProperties": true
17375    ///    },
17376    ///    "proxy": {
17377    ///      "description": "Overrides for the `proxy` option block.",
17378    ///      "type": "object",
17379    ///      "additionalProperties": true
17380    ///    },
17381    ///    "rc": {
17382    ///      "description": "Overrides for the `rc` option block.",
17383    ///      "type": "object",
17384    ///      "additionalProperties": true
17385    ///    },
17386    ///    "restic": {
17387    ///      "description": "Overrides for the `restic` option block.",
17388    ///      "type": "object",
17389    ///      "additionalProperties": true
17390    ///    },
17391    ///    "s3": {
17392    ///      "description": "Overrides for the `s3` option block.",
17393    ///      "type": "object",
17394    ///      "additionalProperties": true
17395    ///    },
17396    ///    "sftp": {
17397    ///      "description": "Overrides for the `sftp` option block.",
17398    ///      "type": "object",
17399    ///      "additionalProperties": true
17400    ///    },
17401    ///    "vfs": {
17402    ///      "description": "Overrides for the `vfs` option block.",
17403    ///      "type": "object",
17404    ///      "additionalProperties": true
17405    ///    },
17406    ///    "webdav": {
17407    ///      "description": "Overrides for the `webdav` option block.",
17408    ///      "type": "object",
17409    ///      "additionalProperties": true
17410    ///    }
17411    ///  },
17412    ///  "additionalProperties": true
17413    ///}
17414    /// ```
17415    /// </details>
17416    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17417    pub struct OptionsSetRequest {
17418        ///Run the command asynchronously. Returns a job id immediately.
17419        #[serde(
17420            rename = "_async",
17421            default,
17422            skip_serializing_if = "::std::option::Option::is_none"
17423        )]
17424        pub async_: ::std::option::Option<bool>,
17425        ///Overrides for the `dlna` option block.
17426        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17427        pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17428        ///Overrides for the `filter` option block.
17429        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17430        pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17431        ///Overrides for the `ftp` option block.
17432        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17433        pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17434        ///Assign the request to a custom stats group.
17435        #[serde(
17436            rename = "_group",
17437            default,
17438            skip_serializing_if = "::std::option::Option::is_none"
17439        )]
17440        pub group: ::std::option::Option<::std::string::String>,
17441        ///Overrides for the `http` option block.
17442        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17443        pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17444        ///Overrides for the `log` option block.
17445        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17446        pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17447        ///Overrides for the `main` option block.
17448        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17449        pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17450        ///Overrides for the `mount` option block.
17451        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17452        pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17453        ///Overrides for the `nfs` option block.
17454        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17455        pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17456        ///Overrides for the `proxy` option block.
17457        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17458        pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17459        ///Overrides for the `rc` option block.
17460        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17461        pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17462        ///Overrides for the `restic` option block.
17463        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17464        pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17465        ///Overrides for the `s3` option block.
17466        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17467        pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17468        ///Overrides for the `sftp` option block.
17469        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17470        pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17471        ///Overrides for the `vfs` option block.
17472        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17473        pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17474        ///Overrides for the `webdav` option block.
17475        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
17476        pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17477    }
17478
17479    impl ::std::convert::From<&OptionsSetRequest> for OptionsSetRequest {
17480        fn from(value: &OptionsSetRequest) -> Self {
17481            value.clone()
17482        }
17483    }
17484
17485    impl ::std::default::Default for OptionsSetRequest {
17486        fn default() -> Self {
17487            Self {
17488                async_: Default::default(),
17489                dlna: Default::default(),
17490                filter: Default::default(),
17491                ftp: Default::default(),
17492                group: Default::default(),
17493                http: Default::default(),
17494                log: Default::default(),
17495                main: Default::default(),
17496                mount: Default::default(),
17497                nfs: Default::default(),
17498                proxy: Default::default(),
17499                rc: Default::default(),
17500                restic: Default::default(),
17501                s3: Default::default(),
17502                sftp: Default::default(),
17503                vfs: Default::default(),
17504                webdav: Default::default(),
17505            }
17506        }
17507    }
17508
17509    ///`PluginsctlAddPluginPrefer`
17510    ///
17511    /// <details><summary>JSON schema</summary>
17512    ///
17513    /// ```json
17514    ///{
17515    ///  "type": "string",
17516    ///  "enum": [
17517    ///    "respond-async"
17518    ///  ]
17519    ///}
17520    /// ```
17521    /// </details>
17522    #[derive(
17523        :: serde :: Deserialize,
17524        :: serde :: Serialize,
17525        Clone,
17526        Copy,
17527        Debug,
17528        Eq,
17529        Hash,
17530        Ord,
17531        PartialEq,
17532        PartialOrd,
17533    )]
17534    pub enum PluginsctlAddPluginPrefer {
17535        #[serde(rename = "respond-async")]
17536        RespondAsync,
17537    }
17538
17539    impl ::std::convert::From<&Self> for PluginsctlAddPluginPrefer {
17540        fn from(value: &PluginsctlAddPluginPrefer) -> Self {
17541            value.clone()
17542        }
17543    }
17544
17545    impl ::std::fmt::Display for PluginsctlAddPluginPrefer {
17546        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17547            match *self {
17548                Self::RespondAsync => f.write_str("respond-async"),
17549            }
17550        }
17551    }
17552
17553    impl ::std::str::FromStr for PluginsctlAddPluginPrefer {
17554        type Err = self::error::ConversionError;
17555        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17556            match value {
17557                "respond-async" => Ok(Self::RespondAsync),
17558                _ => Err("invalid value".into()),
17559            }
17560        }
17561    }
17562
17563    impl ::std::convert::TryFrom<&str> for PluginsctlAddPluginPrefer {
17564        type Error = self::error::ConversionError;
17565        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17566            value.parse()
17567        }
17568    }
17569
17570    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlAddPluginPrefer {
17571        type Error = self::error::ConversionError;
17572        fn try_from(
17573            value: &::std::string::String,
17574        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17575            value.parse()
17576        }
17577    }
17578
17579    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlAddPluginPrefer {
17580        type Error = self::error::ConversionError;
17581        fn try_from(
17582            value: ::std::string::String,
17583        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17584            value.parse()
17585        }
17586    }
17587
17588    ///`PluginsctlAddPluginRequest`
17589    ///
17590    /// <details><summary>JSON schema</summary>
17591    ///
17592    /// ```json
17593    ///{
17594    ///  "type": "object",
17595    ///  "properties": {
17596    ///    "_async": {
17597    ///      "description": "Run the command asynchronously. Returns a job id
17598    /// immediately.",
17599    ///      "type": "boolean"
17600    ///    },
17601    ///    "_group": {
17602    ///      "description": "Assign the request to a custom stats group.",
17603    ///      "type": "string"
17604    ///    },
17605    ///    "url": {
17606    ///      "description": "Repository URL of the plugin to install.",
17607    ///      "type": "string"
17608    ///    }
17609    ///  }
17610    ///}
17611    /// ```
17612    /// </details>
17613    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17614    pub struct PluginsctlAddPluginRequest {
17615        ///Run the command asynchronously. Returns a job id immediately.
17616        #[serde(
17617            rename = "_async",
17618            default,
17619            skip_serializing_if = "::std::option::Option::is_none"
17620        )]
17621        pub async_: ::std::option::Option<bool>,
17622        ///Assign the request to a custom stats group.
17623        #[serde(
17624            rename = "_group",
17625            default,
17626            skip_serializing_if = "::std::option::Option::is_none"
17627        )]
17628        pub group: ::std::option::Option<::std::string::String>,
17629        ///Repository URL of the plugin to install.
17630        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
17631        pub url: ::std::option::Option<::std::string::String>,
17632    }
17633
17634    impl ::std::convert::From<&PluginsctlAddPluginRequest> for PluginsctlAddPluginRequest {
17635        fn from(value: &PluginsctlAddPluginRequest) -> Self {
17636            value.clone()
17637        }
17638    }
17639
17640    impl ::std::default::Default for PluginsctlAddPluginRequest {
17641        fn default() -> Self {
17642            Self {
17643                async_: Default::default(),
17644                group: Default::default(),
17645                url: Default::default(),
17646            }
17647        }
17648    }
17649
17650    ///`PluginsctlGetPluginsForTypePrefer`
17651    ///
17652    /// <details><summary>JSON schema</summary>
17653    ///
17654    /// ```json
17655    ///{
17656    ///  "type": "string",
17657    ///  "enum": [
17658    ///    "respond-async"
17659    ///  ]
17660    ///}
17661    /// ```
17662    /// </details>
17663    #[derive(
17664        :: serde :: Deserialize,
17665        :: serde :: Serialize,
17666        Clone,
17667        Copy,
17668        Debug,
17669        Eq,
17670        Hash,
17671        Ord,
17672        PartialEq,
17673        PartialOrd,
17674    )]
17675    pub enum PluginsctlGetPluginsForTypePrefer {
17676        #[serde(rename = "respond-async")]
17677        RespondAsync,
17678    }
17679
17680    impl ::std::convert::From<&Self> for PluginsctlGetPluginsForTypePrefer {
17681        fn from(value: &PluginsctlGetPluginsForTypePrefer) -> Self {
17682            value.clone()
17683        }
17684    }
17685
17686    impl ::std::fmt::Display for PluginsctlGetPluginsForTypePrefer {
17687        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17688            match *self {
17689                Self::RespondAsync => f.write_str("respond-async"),
17690            }
17691        }
17692    }
17693
17694    impl ::std::str::FromStr for PluginsctlGetPluginsForTypePrefer {
17695        type Err = self::error::ConversionError;
17696        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17697            match value {
17698                "respond-async" => Ok(Self::RespondAsync),
17699                _ => Err("invalid value".into()),
17700            }
17701        }
17702    }
17703
17704    impl ::std::convert::TryFrom<&str> for PluginsctlGetPluginsForTypePrefer {
17705        type Error = self::error::ConversionError;
17706        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17707            value.parse()
17708        }
17709    }
17710
17711    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlGetPluginsForTypePrefer {
17712        type Error = self::error::ConversionError;
17713        fn try_from(
17714            value: &::std::string::String,
17715        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17716            value.parse()
17717        }
17718    }
17719
17720    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlGetPluginsForTypePrefer {
17721        type Error = self::error::ConversionError;
17722        fn try_from(
17723            value: ::std::string::String,
17724        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17725            value.parse()
17726        }
17727    }
17728
17729    ///`PluginsctlGetPluginsForTypeRequest`
17730    ///
17731    /// <details><summary>JSON schema</summary>
17732    ///
17733    /// ```json
17734    ///{
17735    ///  "type": "object",
17736    ///  "properties": {
17737    ///    "_async": {
17738    ///      "description": "Run the command asynchronously. Returns a job id
17739    /// immediately.",
17740    ///      "type": "boolean"
17741    ///    },
17742    ///    "_group": {
17743    ///      "description": "Assign the request to a custom stats group.",
17744    ///      "type": "string"
17745    ///    },
17746    ///    "pluginType": {
17747    ///      "description": "Filter results by plugin type (e.g. `test`).",
17748    ///      "type": "string"
17749    ///    },
17750    ///    "type": {
17751    ///      "description": "MIME type to match when listing plugins.",
17752    ///      "type": "string"
17753    ///    }
17754    ///  }
17755    ///}
17756    /// ```
17757    /// </details>
17758    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17759    pub struct PluginsctlGetPluginsForTypeRequest {
17760        ///Run the command asynchronously. Returns a job id immediately.
17761        #[serde(
17762            rename = "_async",
17763            default,
17764            skip_serializing_if = "::std::option::Option::is_none"
17765        )]
17766        pub async_: ::std::option::Option<bool>,
17767        ///Assign the request to a custom stats group.
17768        #[serde(
17769            rename = "_group",
17770            default,
17771            skip_serializing_if = "::std::option::Option::is_none"
17772        )]
17773        pub group: ::std::option::Option<::std::string::String>,
17774        ///Filter results by plugin type (e.g. `test`).
17775        #[serde(
17776            rename = "pluginType",
17777            default,
17778            skip_serializing_if = "::std::option::Option::is_none"
17779        )]
17780        pub plugin_type: ::std::option::Option<::std::string::String>,
17781        ///MIME type to match when listing plugins.
17782        #[serde(
17783            rename = "type",
17784            default,
17785            skip_serializing_if = "::std::option::Option::is_none"
17786        )]
17787        pub type_: ::std::option::Option<::std::string::String>,
17788    }
17789
17790    impl ::std::convert::From<&PluginsctlGetPluginsForTypeRequest>
17791        for PluginsctlGetPluginsForTypeRequest
17792    {
17793        fn from(value: &PluginsctlGetPluginsForTypeRequest) -> Self {
17794            value.clone()
17795        }
17796    }
17797
17798    impl ::std::default::Default for PluginsctlGetPluginsForTypeRequest {
17799        fn default() -> Self {
17800            Self {
17801                async_: Default::default(),
17802                group: Default::default(),
17803                plugin_type: Default::default(),
17804                type_: Default::default(),
17805            }
17806        }
17807    }
17808
17809    ///`PluginsctlGetPluginsForTypeResponse`
17810    ///
17811    /// <details><summary>JSON schema</summary>
17812    ///
17813    /// ```json
17814    ///{
17815    ///  "type": "object",
17816    ///  "required": [
17817    ///    "loadedPlugins",
17818    ///    "loadedTestPlugins"
17819    ///  ],
17820    ///  "properties": {
17821    ///    "loadedPlugins": {
17822    ///      "description": "Installed plugins keyed by repository name.",
17823    ///      "type": "object",
17824    ///      "additionalProperties": {
17825    ///        "type": "object",
17826    ///        "additionalProperties": true
17827    ///      }
17828    ///    },
17829    ///    "loadedTestPlugins": {
17830    ///      "description": "Installed test plugins keyed by repository name.",
17831    ///      "type": "object",
17832    ///      "additionalProperties": {
17833    ///        "type": "object",
17834    ///        "additionalProperties": true
17835    ///      }
17836    ///    }
17837    ///  }
17838    ///}
17839    /// ```
17840    /// </details>
17841    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17842    pub struct PluginsctlGetPluginsForTypeResponse {
17843        ///Installed plugins keyed by repository name.
17844        #[serde(rename = "loadedPlugins")]
17845        pub loaded_plugins: ::std::collections::HashMap<
17846            ::std::string::String,
17847            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17848        >,
17849        ///Installed test plugins keyed by repository name.
17850        #[serde(rename = "loadedTestPlugins")]
17851        pub loaded_test_plugins: ::std::collections::HashMap<
17852            ::std::string::String,
17853            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
17854        >,
17855    }
17856
17857    impl ::std::convert::From<&PluginsctlGetPluginsForTypeResponse>
17858        for PluginsctlGetPluginsForTypeResponse
17859    {
17860        fn from(value: &PluginsctlGetPluginsForTypeResponse) -> Self {
17861            value.clone()
17862        }
17863    }
17864
17865    ///`PluginsctlListPluginsPrefer`
17866    ///
17867    /// <details><summary>JSON schema</summary>
17868    ///
17869    /// ```json
17870    ///{
17871    ///  "type": "string",
17872    ///  "enum": [
17873    ///    "respond-async"
17874    ///  ]
17875    ///}
17876    /// ```
17877    /// </details>
17878    #[derive(
17879        :: serde :: Deserialize,
17880        :: serde :: Serialize,
17881        Clone,
17882        Copy,
17883        Debug,
17884        Eq,
17885        Hash,
17886        Ord,
17887        PartialEq,
17888        PartialOrd,
17889    )]
17890    pub enum PluginsctlListPluginsPrefer {
17891        #[serde(rename = "respond-async")]
17892        RespondAsync,
17893    }
17894
17895    impl ::std::convert::From<&Self> for PluginsctlListPluginsPrefer {
17896        fn from(value: &PluginsctlListPluginsPrefer) -> Self {
17897            value.clone()
17898        }
17899    }
17900
17901    impl ::std::fmt::Display for PluginsctlListPluginsPrefer {
17902        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17903            match *self {
17904                Self::RespondAsync => f.write_str("respond-async"),
17905            }
17906        }
17907    }
17908
17909    impl ::std::str::FromStr for PluginsctlListPluginsPrefer {
17910        type Err = self::error::ConversionError;
17911        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17912            match value {
17913                "respond-async" => Ok(Self::RespondAsync),
17914                _ => Err("invalid value".into()),
17915            }
17916        }
17917    }
17918
17919    impl ::std::convert::TryFrom<&str> for PluginsctlListPluginsPrefer {
17920        type Error = self::error::ConversionError;
17921        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
17922            value.parse()
17923        }
17924    }
17925
17926    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlListPluginsPrefer {
17927        type Error = self::error::ConversionError;
17928        fn try_from(
17929            value: &::std::string::String,
17930        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17931            value.parse()
17932        }
17933    }
17934
17935    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlListPluginsPrefer {
17936        type Error = self::error::ConversionError;
17937        fn try_from(
17938            value: ::std::string::String,
17939        ) -> ::std::result::Result<Self, self::error::ConversionError> {
17940            value.parse()
17941        }
17942    }
17943
17944    ///`PluginsctlListPluginsRequest`
17945    ///
17946    /// <details><summary>JSON schema</summary>
17947    ///
17948    /// ```json
17949    ///{
17950    ///  "type": "object",
17951    ///  "properties": {
17952    ///    "_async": {
17953    ///      "description": "Run the command asynchronously. Returns a job id
17954    /// immediately.",
17955    ///      "type": "boolean"
17956    ///    },
17957    ///    "_group": {
17958    ///      "description": "Assign the request to a custom stats group.",
17959    ///      "type": "string"
17960    ///    }
17961    ///  }
17962    ///}
17963    /// ```
17964    /// </details>
17965    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
17966    pub struct PluginsctlListPluginsRequest {
17967        ///Run the command asynchronously. Returns a job id immediately.
17968        #[serde(
17969            rename = "_async",
17970            default,
17971            skip_serializing_if = "::std::option::Option::is_none"
17972        )]
17973        pub async_: ::std::option::Option<bool>,
17974        ///Assign the request to a custom stats group.
17975        #[serde(
17976            rename = "_group",
17977            default,
17978            skip_serializing_if = "::std::option::Option::is_none"
17979        )]
17980        pub group: ::std::option::Option<::std::string::String>,
17981    }
17982
17983    impl ::std::convert::From<&PluginsctlListPluginsRequest> for PluginsctlListPluginsRequest {
17984        fn from(value: &PluginsctlListPluginsRequest) -> Self {
17985            value.clone()
17986        }
17987    }
17988
17989    impl ::std::default::Default for PluginsctlListPluginsRequest {
17990        fn default() -> Self {
17991            Self {
17992                async_: Default::default(),
17993                group: Default::default(),
17994            }
17995        }
17996    }
17997
17998    ///`PluginsctlListPluginsResponse`
17999    ///
18000    /// <details><summary>JSON schema</summary>
18001    ///
18002    /// ```json
18003    ///{
18004    ///  "type": "object",
18005    ///  "required": [
18006    ///    "loadedPlugins",
18007    ///    "testPlugins"
18008    ///  ],
18009    ///  "properties": {
18010    ///    "loadedPlugins": {
18011    ///      "description": "Metadata entries for installed plugins.",
18012    ///      "type": "array",
18013    ///      "items": {
18014    ///        "type": "object",
18015    ///        "additionalProperties": true
18016    ///      }
18017    ///    },
18018    ///    "testPlugins": {
18019    ///      "description": "Metadata entries for installed test plugins.",
18020    ///      "type": "array",
18021    ///      "items": {
18022    ///        "type": "object",
18023    ///        "additionalProperties": true
18024    ///      }
18025    ///    }
18026    ///  }
18027    ///}
18028    /// ```
18029    /// </details>
18030    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18031    pub struct PluginsctlListPluginsResponse {
18032        ///Metadata entries for installed plugins.
18033        #[serde(rename = "loadedPlugins")]
18034        pub loaded_plugins:
18035            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
18036        ///Metadata entries for installed test plugins.
18037        #[serde(rename = "testPlugins")]
18038        pub test_plugins:
18039            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
18040    }
18041
18042    impl ::std::convert::From<&PluginsctlListPluginsResponse> for PluginsctlListPluginsResponse {
18043        fn from(value: &PluginsctlListPluginsResponse) -> Self {
18044            value.clone()
18045        }
18046    }
18047
18048    ///`PluginsctlListTestPluginsPrefer`
18049    ///
18050    /// <details><summary>JSON schema</summary>
18051    ///
18052    /// ```json
18053    ///{
18054    ///  "type": "string",
18055    ///  "enum": [
18056    ///    "respond-async"
18057    ///  ]
18058    ///}
18059    /// ```
18060    /// </details>
18061    #[derive(
18062        :: serde :: Deserialize,
18063        :: serde :: Serialize,
18064        Clone,
18065        Copy,
18066        Debug,
18067        Eq,
18068        Hash,
18069        Ord,
18070        PartialEq,
18071        PartialOrd,
18072    )]
18073    pub enum PluginsctlListTestPluginsPrefer {
18074        #[serde(rename = "respond-async")]
18075        RespondAsync,
18076    }
18077
18078    impl ::std::convert::From<&Self> for PluginsctlListTestPluginsPrefer {
18079        fn from(value: &PluginsctlListTestPluginsPrefer) -> Self {
18080            value.clone()
18081        }
18082    }
18083
18084    impl ::std::fmt::Display for PluginsctlListTestPluginsPrefer {
18085        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18086            match *self {
18087                Self::RespondAsync => f.write_str("respond-async"),
18088            }
18089        }
18090    }
18091
18092    impl ::std::str::FromStr for PluginsctlListTestPluginsPrefer {
18093        type Err = self::error::ConversionError;
18094        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18095            match value {
18096                "respond-async" => Ok(Self::RespondAsync),
18097                _ => Err("invalid value".into()),
18098            }
18099        }
18100    }
18101
18102    impl ::std::convert::TryFrom<&str> for PluginsctlListTestPluginsPrefer {
18103        type Error = self::error::ConversionError;
18104        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18105            value.parse()
18106        }
18107    }
18108
18109    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlListTestPluginsPrefer {
18110        type Error = self::error::ConversionError;
18111        fn try_from(
18112            value: &::std::string::String,
18113        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18114            value.parse()
18115        }
18116    }
18117
18118    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlListTestPluginsPrefer {
18119        type Error = self::error::ConversionError;
18120        fn try_from(
18121            value: ::std::string::String,
18122        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18123            value.parse()
18124        }
18125    }
18126
18127    ///`PluginsctlListTestPluginsRequest`
18128    ///
18129    /// <details><summary>JSON schema</summary>
18130    ///
18131    /// ```json
18132    ///{
18133    ///  "type": "object",
18134    ///  "properties": {
18135    ///    "_async": {
18136    ///      "description": "Run the command asynchronously. Returns a job id
18137    /// immediately.",
18138    ///      "type": "boolean"
18139    ///    },
18140    ///    "_group": {
18141    ///      "description": "Assign the request to a custom stats group.",
18142    ///      "type": "string"
18143    ///    }
18144    ///  }
18145    ///}
18146    /// ```
18147    /// </details>
18148    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18149    pub struct PluginsctlListTestPluginsRequest {
18150        ///Run the command asynchronously. Returns a job id immediately.
18151        #[serde(
18152            rename = "_async",
18153            default,
18154            skip_serializing_if = "::std::option::Option::is_none"
18155        )]
18156        pub async_: ::std::option::Option<bool>,
18157        ///Assign the request to a custom stats group.
18158        #[serde(
18159            rename = "_group",
18160            default,
18161            skip_serializing_if = "::std::option::Option::is_none"
18162        )]
18163        pub group: ::std::option::Option<::std::string::String>,
18164    }
18165
18166    impl ::std::convert::From<&PluginsctlListTestPluginsRequest> for PluginsctlListTestPluginsRequest {
18167        fn from(value: &PluginsctlListTestPluginsRequest) -> Self {
18168            value.clone()
18169        }
18170    }
18171
18172    impl ::std::default::Default for PluginsctlListTestPluginsRequest {
18173        fn default() -> Self {
18174            Self {
18175                async_: Default::default(),
18176                group: Default::default(),
18177            }
18178        }
18179    }
18180
18181    ///`PluginsctlListTestPluginsResponse`
18182    ///
18183    /// <details><summary>JSON schema</summary>
18184    ///
18185    /// ```json
18186    ///{
18187    ///  "type": "object",
18188    ///  "required": [
18189    ///    "loadedTestPlugins"
18190    ///  ],
18191    ///  "properties": {
18192    ///    "loadedTestPlugins": {
18193    ///      "description": "Installed test plugin metadata keyed by
18194    /// repository.",
18195    ///      "type": "object",
18196    ///      "additionalProperties": {
18197    ///        "type": "object",
18198    ///        "additionalProperties": true
18199    ///      }
18200    ///    }
18201    ///  }
18202    ///}
18203    /// ```
18204    /// </details>
18205    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18206    pub struct PluginsctlListTestPluginsResponse {
18207        ///Installed test plugin metadata keyed by repository.
18208        #[serde(rename = "loadedTestPlugins")]
18209        pub loaded_test_plugins: ::std::collections::HashMap<
18210            ::std::string::String,
18211            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
18212        >,
18213    }
18214
18215    impl ::std::convert::From<&PluginsctlListTestPluginsResponse>
18216        for PluginsctlListTestPluginsResponse
18217    {
18218        fn from(value: &PluginsctlListTestPluginsResponse) -> Self {
18219            value.clone()
18220        }
18221    }
18222
18223    ///`PluginsctlRemovePluginPrefer`
18224    ///
18225    /// <details><summary>JSON schema</summary>
18226    ///
18227    /// ```json
18228    ///{
18229    ///  "type": "string",
18230    ///  "enum": [
18231    ///    "respond-async"
18232    ///  ]
18233    ///}
18234    /// ```
18235    /// </details>
18236    #[derive(
18237        :: serde :: Deserialize,
18238        :: serde :: Serialize,
18239        Clone,
18240        Copy,
18241        Debug,
18242        Eq,
18243        Hash,
18244        Ord,
18245        PartialEq,
18246        PartialOrd,
18247    )]
18248    pub enum PluginsctlRemovePluginPrefer {
18249        #[serde(rename = "respond-async")]
18250        RespondAsync,
18251    }
18252
18253    impl ::std::convert::From<&Self> for PluginsctlRemovePluginPrefer {
18254        fn from(value: &PluginsctlRemovePluginPrefer) -> Self {
18255            value.clone()
18256        }
18257    }
18258
18259    impl ::std::fmt::Display for PluginsctlRemovePluginPrefer {
18260        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18261            match *self {
18262                Self::RespondAsync => f.write_str("respond-async"),
18263            }
18264        }
18265    }
18266
18267    impl ::std::str::FromStr for PluginsctlRemovePluginPrefer {
18268        type Err = self::error::ConversionError;
18269        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18270            match value {
18271                "respond-async" => Ok(Self::RespondAsync),
18272                _ => Err("invalid value".into()),
18273            }
18274        }
18275    }
18276
18277    impl ::std::convert::TryFrom<&str> for PluginsctlRemovePluginPrefer {
18278        type Error = self::error::ConversionError;
18279        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18280            value.parse()
18281        }
18282    }
18283
18284    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlRemovePluginPrefer {
18285        type Error = self::error::ConversionError;
18286        fn try_from(
18287            value: &::std::string::String,
18288        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18289            value.parse()
18290        }
18291    }
18292
18293    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlRemovePluginPrefer {
18294        type Error = self::error::ConversionError;
18295        fn try_from(
18296            value: ::std::string::String,
18297        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18298            value.parse()
18299        }
18300    }
18301
18302    ///`PluginsctlRemovePluginRequest`
18303    ///
18304    /// <details><summary>JSON schema</summary>
18305    ///
18306    /// ```json
18307    ///{
18308    ///  "type": "object",
18309    ///  "properties": {
18310    ///    "_async": {
18311    ///      "description": "Run the command asynchronously. Returns a job id
18312    /// immediately.",
18313    ///      "type": "boolean"
18314    ///    },
18315    ///    "_group": {
18316    ///      "description": "Assign the request to a custom stats group.",
18317    ///      "type": "string"
18318    ///    },
18319    ///    "name": {
18320    ///      "description": "Name of the plugin to uninstall.",
18321    ///      "type": "string"
18322    ///    }
18323    ///  }
18324    ///}
18325    /// ```
18326    /// </details>
18327    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18328    pub struct PluginsctlRemovePluginRequest {
18329        ///Run the command asynchronously. Returns a job id immediately.
18330        #[serde(
18331            rename = "_async",
18332            default,
18333            skip_serializing_if = "::std::option::Option::is_none"
18334        )]
18335        pub async_: ::std::option::Option<bool>,
18336        ///Assign the request to a custom stats group.
18337        #[serde(
18338            rename = "_group",
18339            default,
18340            skip_serializing_if = "::std::option::Option::is_none"
18341        )]
18342        pub group: ::std::option::Option<::std::string::String>,
18343        ///Name of the plugin to uninstall.
18344        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
18345        pub name: ::std::option::Option<::std::string::String>,
18346    }
18347
18348    impl ::std::convert::From<&PluginsctlRemovePluginRequest> for PluginsctlRemovePluginRequest {
18349        fn from(value: &PluginsctlRemovePluginRequest) -> Self {
18350            value.clone()
18351        }
18352    }
18353
18354    impl ::std::default::Default for PluginsctlRemovePluginRequest {
18355        fn default() -> Self {
18356            Self {
18357                async_: Default::default(),
18358                group: Default::default(),
18359                name: Default::default(),
18360            }
18361        }
18362    }
18363
18364    ///`PluginsctlRemoveTestPluginPrefer`
18365    ///
18366    /// <details><summary>JSON schema</summary>
18367    ///
18368    /// ```json
18369    ///{
18370    ///  "type": "string",
18371    ///  "enum": [
18372    ///    "respond-async"
18373    ///  ]
18374    ///}
18375    /// ```
18376    /// </details>
18377    #[derive(
18378        :: serde :: Deserialize,
18379        :: serde :: Serialize,
18380        Clone,
18381        Copy,
18382        Debug,
18383        Eq,
18384        Hash,
18385        Ord,
18386        PartialEq,
18387        PartialOrd,
18388    )]
18389    pub enum PluginsctlRemoveTestPluginPrefer {
18390        #[serde(rename = "respond-async")]
18391        RespondAsync,
18392    }
18393
18394    impl ::std::convert::From<&Self> for PluginsctlRemoveTestPluginPrefer {
18395        fn from(value: &PluginsctlRemoveTestPluginPrefer) -> Self {
18396            value.clone()
18397        }
18398    }
18399
18400    impl ::std::fmt::Display for PluginsctlRemoveTestPluginPrefer {
18401        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18402            match *self {
18403                Self::RespondAsync => f.write_str("respond-async"),
18404            }
18405        }
18406    }
18407
18408    impl ::std::str::FromStr for PluginsctlRemoveTestPluginPrefer {
18409        type Err = self::error::ConversionError;
18410        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18411            match value {
18412                "respond-async" => Ok(Self::RespondAsync),
18413                _ => Err("invalid value".into()),
18414            }
18415        }
18416    }
18417
18418    impl ::std::convert::TryFrom<&str> for PluginsctlRemoveTestPluginPrefer {
18419        type Error = self::error::ConversionError;
18420        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18421            value.parse()
18422        }
18423    }
18424
18425    impl ::std::convert::TryFrom<&::std::string::String> for PluginsctlRemoveTestPluginPrefer {
18426        type Error = self::error::ConversionError;
18427        fn try_from(
18428            value: &::std::string::String,
18429        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18430            value.parse()
18431        }
18432    }
18433
18434    impl ::std::convert::TryFrom<::std::string::String> for PluginsctlRemoveTestPluginPrefer {
18435        type Error = self::error::ConversionError;
18436        fn try_from(
18437            value: ::std::string::String,
18438        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18439            value.parse()
18440        }
18441    }
18442
18443    ///`PluginsctlRemoveTestPluginRequest`
18444    ///
18445    /// <details><summary>JSON schema</summary>
18446    ///
18447    /// ```json
18448    ///{
18449    ///  "type": "object",
18450    ///  "properties": {
18451    ///    "_async": {
18452    ///      "description": "Run the command asynchronously. Returns a job id
18453    /// immediately.",
18454    ///      "type": "boolean"
18455    ///    },
18456    ///    "_group": {
18457    ///      "description": "Assign the request to a custom stats group.",
18458    ///      "type": "string"
18459    ///    },
18460    ///    "name": {
18461    ///      "description": "Name of the test plugin to uninstall.",
18462    ///      "type": "string"
18463    ///    }
18464    ///  }
18465    ///}
18466    /// ```
18467    /// </details>
18468    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18469    pub struct PluginsctlRemoveTestPluginRequest {
18470        ///Run the command asynchronously. Returns a job id immediately.
18471        #[serde(
18472            rename = "_async",
18473            default,
18474            skip_serializing_if = "::std::option::Option::is_none"
18475        )]
18476        pub async_: ::std::option::Option<bool>,
18477        ///Assign the request to a custom stats group.
18478        #[serde(
18479            rename = "_group",
18480            default,
18481            skip_serializing_if = "::std::option::Option::is_none"
18482        )]
18483        pub group: ::std::option::Option<::std::string::String>,
18484        ///Name of the test plugin to uninstall.
18485        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
18486        pub name: ::std::option::Option<::std::string::String>,
18487    }
18488
18489    impl ::std::convert::From<&PluginsctlRemoveTestPluginRequest>
18490        for PluginsctlRemoveTestPluginRequest
18491    {
18492        fn from(value: &PluginsctlRemoveTestPluginRequest) -> Self {
18493            value.clone()
18494        }
18495    }
18496
18497    impl ::std::default::Default for PluginsctlRemoveTestPluginRequest {
18498        fn default() -> Self {
18499            Self {
18500                async_: Default::default(),
18501                group: Default::default(),
18502                name: Default::default(),
18503            }
18504        }
18505    }
18506
18507    ///`RcError`
18508    ///
18509    /// <details><summary>JSON schema</summary>
18510    ///
18511    /// ```json
18512    ///{
18513    ///  "type": "object",
18514    ///  "required": [
18515    ///    "error",
18516    ///    "input",
18517    ///    "path",
18518    ///    "status"
18519    ///  ],
18520    ///  "properties": {
18521    ///    "error": {
18522    ///      "type": "string"
18523    ///    },
18524    ///    "input": {
18525    ///      "description": "Original request parameters echoed for debugging.",
18526    ///      "type": [
18527    ///        "object",
18528    ///        "null"
18529    ///      ],
18530    ///      "additionalProperties": {}
18531    ///    },
18532    ///    "path": {
18533    ///      "type": "string"
18534    ///    },
18535    ///    "status": {
18536    ///      "type": "integer"
18537    ///    }
18538    ///  }
18539    ///}
18540    /// ```
18541    /// </details>
18542    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18543    pub struct RcError {
18544        pub error: ::std::string::String,
18545        ///Original request parameters echoed for debugging.
18546        pub input:
18547            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
18548        pub path: ::std::string::String,
18549        pub status: i64,
18550    }
18551
18552    impl ::std::convert::From<&RcError> for RcError {
18553        fn from(value: &RcError) -> Self {
18554            value.clone()
18555        }
18556    }
18557
18558    ///`RcErrorPrefer`
18559    ///
18560    /// <details><summary>JSON schema</summary>
18561    ///
18562    /// ```json
18563    ///{
18564    ///  "type": "string",
18565    ///  "enum": [
18566    ///    "respond-async"
18567    ///  ]
18568    ///}
18569    /// ```
18570    /// </details>
18571    #[derive(
18572        :: serde :: Deserialize,
18573        :: serde :: Serialize,
18574        Clone,
18575        Copy,
18576        Debug,
18577        Eq,
18578        Hash,
18579        Ord,
18580        PartialEq,
18581        PartialOrd,
18582    )]
18583    pub enum RcErrorPrefer {
18584        #[serde(rename = "respond-async")]
18585        RespondAsync,
18586    }
18587
18588    impl ::std::convert::From<&Self> for RcErrorPrefer {
18589        fn from(value: &RcErrorPrefer) -> Self {
18590            value.clone()
18591        }
18592    }
18593
18594    impl ::std::fmt::Display for RcErrorPrefer {
18595        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18596            match *self {
18597                Self::RespondAsync => f.write_str("respond-async"),
18598            }
18599        }
18600    }
18601
18602    impl ::std::str::FromStr for RcErrorPrefer {
18603        type Err = self::error::ConversionError;
18604        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18605            match value {
18606                "respond-async" => Ok(Self::RespondAsync),
18607                _ => Err("invalid value".into()),
18608            }
18609        }
18610    }
18611
18612    impl ::std::convert::TryFrom<&str> for RcErrorPrefer {
18613        type Error = self::error::ConversionError;
18614        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18615            value.parse()
18616        }
18617    }
18618
18619    impl ::std::convert::TryFrom<&::std::string::String> for RcErrorPrefer {
18620        type Error = self::error::ConversionError;
18621        fn try_from(
18622            value: &::std::string::String,
18623        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18624            value.parse()
18625        }
18626    }
18627
18628    impl ::std::convert::TryFrom<::std::string::String> for RcErrorPrefer {
18629        type Error = self::error::ConversionError;
18630        fn try_from(
18631            value: ::std::string::String,
18632        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18633            value.parse()
18634        }
18635    }
18636
18637    ///`RcErrorRequest`
18638    ///
18639    /// <details><summary>JSON schema</summary>
18640    ///
18641    /// ```json
18642    ///{
18643    ///  "type": "object",
18644    ///  "properties": {
18645    ///    "_async": {
18646    ///      "description": "Run the command asynchronously. Returns a job id
18647    /// immediately.",
18648    ///      "type": "boolean"
18649    ///    }
18650    ///  },
18651    ///  "additionalProperties": true
18652    ///}
18653    /// ```
18654    /// </details>
18655    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18656    pub struct RcErrorRequest {
18657        ///Run the command asynchronously. Returns a job id immediately.
18658        #[serde(
18659            rename = "_async",
18660            default,
18661            skip_serializing_if = "::std::option::Option::is_none"
18662        )]
18663        pub async_: ::std::option::Option<bool>,
18664    }
18665
18666    impl ::std::convert::From<&RcErrorRequest> for RcErrorRequest {
18667        fn from(value: &RcErrorRequest) -> Self {
18668            value.clone()
18669        }
18670    }
18671
18672    impl ::std::default::Default for RcErrorRequest {
18673        fn default() -> Self {
18674            Self {
18675                async_: Default::default(),
18676            }
18677        }
18678    }
18679
18680    ///`RcListPrefer`
18681    ///
18682    /// <details><summary>JSON schema</summary>
18683    ///
18684    /// ```json
18685    ///{
18686    ///  "type": "string",
18687    ///  "enum": [
18688    ///    "respond-async"
18689    ///  ]
18690    ///}
18691    /// ```
18692    /// </details>
18693    #[derive(
18694        :: serde :: Deserialize,
18695        :: serde :: Serialize,
18696        Clone,
18697        Copy,
18698        Debug,
18699        Eq,
18700        Hash,
18701        Ord,
18702        PartialEq,
18703        PartialOrd,
18704    )]
18705    pub enum RcListPrefer {
18706        #[serde(rename = "respond-async")]
18707        RespondAsync,
18708    }
18709
18710    impl ::std::convert::From<&Self> for RcListPrefer {
18711        fn from(value: &RcListPrefer) -> Self {
18712            value.clone()
18713        }
18714    }
18715
18716    impl ::std::fmt::Display for RcListPrefer {
18717        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18718            match *self {
18719                Self::RespondAsync => f.write_str("respond-async"),
18720            }
18721        }
18722    }
18723
18724    impl ::std::str::FromStr for RcListPrefer {
18725        type Err = self::error::ConversionError;
18726        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18727            match value {
18728                "respond-async" => Ok(Self::RespondAsync),
18729                _ => Err("invalid value".into()),
18730            }
18731        }
18732    }
18733
18734    impl ::std::convert::TryFrom<&str> for RcListPrefer {
18735        type Error = self::error::ConversionError;
18736        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
18737            value.parse()
18738        }
18739    }
18740
18741    impl ::std::convert::TryFrom<&::std::string::String> for RcListPrefer {
18742        type Error = self::error::ConversionError;
18743        fn try_from(
18744            value: &::std::string::String,
18745        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18746            value.parse()
18747        }
18748    }
18749
18750    impl ::std::convert::TryFrom<::std::string::String> for RcListPrefer {
18751        type Error = self::error::ConversionError;
18752        fn try_from(
18753            value: ::std::string::String,
18754        ) -> ::std::result::Result<Self, self::error::ConversionError> {
18755            value.parse()
18756        }
18757    }
18758
18759    ///`RcListRequest`
18760    ///
18761    /// <details><summary>JSON schema</summary>
18762    ///
18763    /// ```json
18764    ///{
18765    ///  "type": "object",
18766    ///  "properties": {
18767    ///    "_async": {
18768    ///      "description": "Run the command asynchronously. Returns a job id
18769    /// immediately.",
18770    ///      "type": "boolean"
18771    ///    },
18772    ///    "_group": {
18773    ///      "description": "Assign the request to a custom stats group.",
18774    ///      "type": "string"
18775    ///    }
18776    ///  }
18777    ///}
18778    /// ```
18779    /// </details>
18780    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18781    pub struct RcListRequest {
18782        ///Run the command asynchronously. Returns a job id immediately.
18783        #[serde(
18784            rename = "_async",
18785            default,
18786            skip_serializing_if = "::std::option::Option::is_none"
18787        )]
18788        pub async_: ::std::option::Option<bool>,
18789        ///Assign the request to a custom stats group.
18790        #[serde(
18791            rename = "_group",
18792            default,
18793            skip_serializing_if = "::std::option::Option::is_none"
18794        )]
18795        pub group: ::std::option::Option<::std::string::String>,
18796    }
18797
18798    impl ::std::convert::From<&RcListRequest> for RcListRequest {
18799        fn from(value: &RcListRequest) -> Self {
18800            value.clone()
18801        }
18802    }
18803
18804    impl ::std::default::Default for RcListRequest {
18805        fn default() -> Self {
18806            Self {
18807                async_: Default::default(),
18808                group: Default::default(),
18809            }
18810        }
18811    }
18812
18813    ///`RcListResponse`
18814    ///
18815    /// <details><summary>JSON schema</summary>
18816    ///
18817    /// ```json
18818    ///{
18819    ///  "type": "object",
18820    ///  "required": [
18821    ///    "commands"
18822    ///  ],
18823    ///  "properties": {
18824    ///    "commands": {
18825    ///      "type": "array",
18826    ///      "items": {
18827    ///        "type": "object",
18828    ///        "properties": {
18829    ///          "AuthRequired": {
18830    ///            "type": "boolean"
18831    ///          },
18832    ///          "Help": {
18833    ///            "type": "string"
18834    ///          },
18835    ///          "NeedsRequest": {
18836    ///            "type": "boolean"
18837    ///          },
18838    ///          "NeedsResponse": {
18839    ///            "type": "boolean"
18840    ///          },
18841    ///          "Path": {
18842    ///            "type": "string"
18843    ///          },
18844    ///          "Title": {
18845    ///            "type": "string"
18846    ///          }
18847    ///        },
18848    ///        "additionalProperties": true
18849    ///      }
18850    ///    }
18851    ///  }
18852    ///}
18853    /// ```
18854    /// </details>
18855    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18856    pub struct RcListResponse {
18857        pub commands: ::std::vec::Vec<RcListResponseCommandsItem>,
18858    }
18859
18860    impl ::std::convert::From<&RcListResponse> for RcListResponse {
18861        fn from(value: &RcListResponse) -> Self {
18862            value.clone()
18863        }
18864    }
18865
18866    ///`RcListResponseCommandsItem`
18867    ///
18868    /// <details><summary>JSON schema</summary>
18869    ///
18870    /// ```json
18871    ///{
18872    ///  "type": "object",
18873    ///  "properties": {
18874    ///    "AuthRequired": {
18875    ///      "type": "boolean"
18876    ///    },
18877    ///    "Help": {
18878    ///      "type": "string"
18879    ///    },
18880    ///    "NeedsRequest": {
18881    ///      "type": "boolean"
18882    ///    },
18883    ///    "NeedsResponse": {
18884    ///      "type": "boolean"
18885    ///    },
18886    ///    "Path": {
18887    ///      "type": "string"
18888    ///    },
18889    ///    "Title": {
18890    ///      "type": "string"
18891    ///    }
18892    ///  },
18893    ///  "additionalProperties": true
18894    ///}
18895    /// ```
18896    /// </details>
18897    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
18898    pub struct RcListResponseCommandsItem {
18899        #[serde(
18900            rename = "AuthRequired",
18901            default,
18902            skip_serializing_if = "::std::option::Option::is_none"
18903        )]
18904        pub auth_required: ::std::option::Option<bool>,
18905        #[serde(
18906            rename = "Help",
18907            default,
18908            skip_serializing_if = "::std::option::Option::is_none"
18909        )]
18910        pub help: ::std::option::Option<::std::string::String>,
18911        #[serde(
18912            rename = "NeedsRequest",
18913            default,
18914            skip_serializing_if = "::std::option::Option::is_none"
18915        )]
18916        pub needs_request: ::std::option::Option<bool>,
18917        #[serde(
18918            rename = "NeedsResponse",
18919            default,
18920            skip_serializing_if = "::std::option::Option::is_none"
18921        )]
18922        pub needs_response: ::std::option::Option<bool>,
18923        #[serde(
18924            rename = "Path",
18925            default,
18926            skip_serializing_if = "::std::option::Option::is_none"
18927        )]
18928        pub path: ::std::option::Option<::std::string::String>,
18929        #[serde(
18930            rename = "Title",
18931            default,
18932            skip_serializing_if = "::std::option::Option::is_none"
18933        )]
18934        pub title: ::std::option::Option<::std::string::String>,
18935    }
18936
18937    impl ::std::convert::From<&RcListResponseCommandsItem> for RcListResponseCommandsItem {
18938        fn from(value: &RcListResponseCommandsItem) -> Self {
18939            value.clone()
18940        }
18941    }
18942
18943    impl ::std::default::Default for RcListResponseCommandsItem {
18944        fn default() -> Self {
18945            Self {
18946                auth_required: Default::default(),
18947                help: Default::default(),
18948                needs_request: Default::default(),
18949                needs_response: Default::default(),
18950                path: Default::default(),
18951                title: Default::default(),
18952            }
18953        }
18954    }
18955
18956    ///`RcNoopAuthPrefer`
18957    ///
18958    /// <details><summary>JSON schema</summary>
18959    ///
18960    /// ```json
18961    ///{
18962    ///  "type": "string",
18963    ///  "enum": [
18964    ///    "respond-async"
18965    ///  ]
18966    ///}
18967    /// ```
18968    /// </details>
18969    #[derive(
18970        :: serde :: Deserialize,
18971        :: serde :: Serialize,
18972        Clone,
18973        Copy,
18974        Debug,
18975        Eq,
18976        Hash,
18977        Ord,
18978        PartialEq,
18979        PartialOrd,
18980    )]
18981    pub enum RcNoopAuthPrefer {
18982        #[serde(rename = "respond-async")]
18983        RespondAsync,
18984    }
18985
18986    impl ::std::convert::From<&Self> for RcNoopAuthPrefer {
18987        fn from(value: &RcNoopAuthPrefer) -> Self {
18988            value.clone()
18989        }
18990    }
18991
18992    impl ::std::fmt::Display for RcNoopAuthPrefer {
18993        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18994            match *self {
18995                Self::RespondAsync => f.write_str("respond-async"),
18996            }
18997        }
18998    }
18999
19000    impl ::std::str::FromStr for RcNoopAuthPrefer {
19001        type Err = self::error::ConversionError;
19002        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19003            match value {
19004                "respond-async" => Ok(Self::RespondAsync),
19005                _ => Err("invalid value".into()),
19006            }
19007        }
19008    }
19009
19010    impl ::std::convert::TryFrom<&str> for RcNoopAuthPrefer {
19011        type Error = self::error::ConversionError;
19012        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19013            value.parse()
19014        }
19015    }
19016
19017    impl ::std::convert::TryFrom<&::std::string::String> for RcNoopAuthPrefer {
19018        type Error = self::error::ConversionError;
19019        fn try_from(
19020            value: &::std::string::String,
19021        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19022            value.parse()
19023        }
19024    }
19025
19026    impl ::std::convert::TryFrom<::std::string::String> for RcNoopAuthPrefer {
19027        type Error = self::error::ConversionError;
19028        fn try_from(
19029            value: ::std::string::String,
19030        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19031            value.parse()
19032        }
19033    }
19034
19035    ///`RcNoopAuthRequest`
19036    ///
19037    /// <details><summary>JSON schema</summary>
19038    ///
19039    /// ```json
19040    ///{
19041    ///  "type": "object",
19042    ///  "properties": {
19043    ///    "_async": {
19044    ///      "description": "Run the command asynchronously. Returns a job id
19045    /// immediately.",
19046    ///      "type": "boolean"
19047    ///    }
19048    ///  },
19049    ///  "additionalProperties": true
19050    ///}
19051    /// ```
19052    /// </details>
19053    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19054    pub struct RcNoopAuthRequest {
19055        ///Run the command asynchronously. Returns a job id immediately.
19056        #[serde(
19057            rename = "_async",
19058            default,
19059            skip_serializing_if = "::std::option::Option::is_none"
19060        )]
19061        pub async_: ::std::option::Option<bool>,
19062    }
19063
19064    impl ::std::convert::From<&RcNoopAuthRequest> for RcNoopAuthRequest {
19065        fn from(value: &RcNoopAuthRequest) -> Self {
19066            value.clone()
19067        }
19068    }
19069
19070    impl ::std::default::Default for RcNoopAuthRequest {
19071        fn default() -> Self {
19072            Self {
19073                async_: Default::default(),
19074            }
19075        }
19076    }
19077
19078    ///`RcNoopPrefer`
19079    ///
19080    /// <details><summary>JSON schema</summary>
19081    ///
19082    /// ```json
19083    ///{
19084    ///  "type": "string",
19085    ///  "enum": [
19086    ///    "respond-async"
19087    ///  ]
19088    ///}
19089    /// ```
19090    /// </details>
19091    #[derive(
19092        :: serde :: Deserialize,
19093        :: serde :: Serialize,
19094        Clone,
19095        Copy,
19096        Debug,
19097        Eq,
19098        Hash,
19099        Ord,
19100        PartialEq,
19101        PartialOrd,
19102    )]
19103    pub enum RcNoopPrefer {
19104        #[serde(rename = "respond-async")]
19105        RespondAsync,
19106    }
19107
19108    impl ::std::convert::From<&Self> for RcNoopPrefer {
19109        fn from(value: &RcNoopPrefer) -> Self {
19110            value.clone()
19111        }
19112    }
19113
19114    impl ::std::fmt::Display for RcNoopPrefer {
19115        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
19116            match *self {
19117                Self::RespondAsync => f.write_str("respond-async"),
19118            }
19119        }
19120    }
19121
19122    impl ::std::str::FromStr for RcNoopPrefer {
19123        type Err = self::error::ConversionError;
19124        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19125            match value {
19126                "respond-async" => Ok(Self::RespondAsync),
19127                _ => Err("invalid value".into()),
19128            }
19129        }
19130    }
19131
19132    impl ::std::convert::TryFrom<&str> for RcNoopPrefer {
19133        type Error = self::error::ConversionError;
19134        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19135            value.parse()
19136        }
19137    }
19138
19139    impl ::std::convert::TryFrom<&::std::string::String> for RcNoopPrefer {
19140        type Error = self::error::ConversionError;
19141        fn try_from(
19142            value: &::std::string::String,
19143        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19144            value.parse()
19145        }
19146    }
19147
19148    impl ::std::convert::TryFrom<::std::string::String> for RcNoopPrefer {
19149        type Error = self::error::ConversionError;
19150        fn try_from(
19151            value: ::std::string::String,
19152        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19153            value.parse()
19154        }
19155    }
19156
19157    ///`RcNoopRequest`
19158    ///
19159    /// <details><summary>JSON schema</summary>
19160    ///
19161    /// ```json
19162    ///{
19163    ///  "type": "object",
19164    ///  "properties": {
19165    ///    "_async": {
19166    ///      "description": "Run the command asynchronously. Returns a job id
19167    /// immediately.",
19168    ///      "type": "boolean"
19169    ///    }
19170    ///  },
19171    ///  "additionalProperties": true
19172    ///}
19173    /// ```
19174    /// </details>
19175    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19176    pub struct RcNoopRequest {
19177        ///Run the command asynchronously. Returns a job id immediately.
19178        #[serde(
19179            rename = "_async",
19180            default,
19181            skip_serializing_if = "::std::option::Option::is_none"
19182        )]
19183        pub async_: ::std::option::Option<bool>,
19184    }
19185
19186    impl ::std::convert::From<&RcNoopRequest> for RcNoopRequest {
19187        fn from(value: &RcNoopRequest) -> Self {
19188            value.clone()
19189        }
19190    }
19191
19192    impl ::std::default::Default for RcNoopRequest {
19193        fn default() -> Self {
19194            Self {
19195                async_: Default::default(),
19196            }
19197        }
19198    }
19199
19200    ///`ServeListPrefer`
19201    ///
19202    /// <details><summary>JSON schema</summary>
19203    ///
19204    /// ```json
19205    ///{
19206    ///  "type": "string",
19207    ///  "enum": [
19208    ///    "respond-async"
19209    ///  ]
19210    ///}
19211    /// ```
19212    /// </details>
19213    #[derive(
19214        :: serde :: Deserialize,
19215        :: serde :: Serialize,
19216        Clone,
19217        Copy,
19218        Debug,
19219        Eq,
19220        Hash,
19221        Ord,
19222        PartialEq,
19223        PartialOrd,
19224    )]
19225    pub enum ServeListPrefer {
19226        #[serde(rename = "respond-async")]
19227        RespondAsync,
19228    }
19229
19230    impl ::std::convert::From<&Self> for ServeListPrefer {
19231        fn from(value: &ServeListPrefer) -> Self {
19232            value.clone()
19233        }
19234    }
19235
19236    impl ::std::fmt::Display for ServeListPrefer {
19237        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
19238            match *self {
19239                Self::RespondAsync => f.write_str("respond-async"),
19240            }
19241        }
19242    }
19243
19244    impl ::std::str::FromStr for ServeListPrefer {
19245        type Err = self::error::ConversionError;
19246        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19247            match value {
19248                "respond-async" => Ok(Self::RespondAsync),
19249                _ => Err("invalid value".into()),
19250            }
19251        }
19252    }
19253
19254    impl ::std::convert::TryFrom<&str> for ServeListPrefer {
19255        type Error = self::error::ConversionError;
19256        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19257            value.parse()
19258        }
19259    }
19260
19261    impl ::std::convert::TryFrom<&::std::string::String> for ServeListPrefer {
19262        type Error = self::error::ConversionError;
19263        fn try_from(
19264            value: &::std::string::String,
19265        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19266            value.parse()
19267        }
19268    }
19269
19270    impl ::std::convert::TryFrom<::std::string::String> for ServeListPrefer {
19271        type Error = self::error::ConversionError;
19272        fn try_from(
19273            value: ::std::string::String,
19274        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19275            value.parse()
19276        }
19277    }
19278
19279    ///`ServeListRequest`
19280    ///
19281    /// <details><summary>JSON schema</summary>
19282    ///
19283    /// ```json
19284    ///{
19285    ///  "type": "object",
19286    ///  "properties": {
19287    ///    "_async": {
19288    ///      "description": "Run the command asynchronously. Returns a job id
19289    /// immediately.",
19290    ///      "type": "boolean"
19291    ///    },
19292    ///    "_group": {
19293    ///      "description": "Assign the request to a custom stats group.",
19294    ///      "type": "string"
19295    ///    }
19296    ///  }
19297    ///}
19298    /// ```
19299    /// </details>
19300    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19301    pub struct ServeListRequest {
19302        ///Run the command asynchronously. Returns a job id immediately.
19303        #[serde(
19304            rename = "_async",
19305            default,
19306            skip_serializing_if = "::std::option::Option::is_none"
19307        )]
19308        pub async_: ::std::option::Option<bool>,
19309        ///Assign the request to a custom stats group.
19310        #[serde(
19311            rename = "_group",
19312            default,
19313            skip_serializing_if = "::std::option::Option::is_none"
19314        )]
19315        pub group: ::std::option::Option<::std::string::String>,
19316    }
19317
19318    impl ::std::convert::From<&ServeListRequest> for ServeListRequest {
19319        fn from(value: &ServeListRequest) -> Self {
19320            value.clone()
19321        }
19322    }
19323
19324    impl ::std::default::Default for ServeListRequest {
19325        fn default() -> Self {
19326            Self {
19327                async_: Default::default(),
19328                group: Default::default(),
19329            }
19330        }
19331    }
19332
19333    ///`ServeListResponse`
19334    ///
19335    /// <details><summary>JSON schema</summary>
19336    ///
19337    /// ```json
19338    ///{
19339    ///  "type": "object",
19340    ///  "required": [
19341    ///    "list"
19342    ///  ],
19343    ///  "properties": {
19344    ///    "list": {
19345    ///      "type": "array",
19346    ///      "items": {
19347    ///        "type": "object",
19348    ///        "required": [
19349    ///          "addr",
19350    ///          "id"
19351    ///        ],
19352    ///        "properties": {
19353    ///          "addr": {
19354    ///            "description": "Address and port the server is listening
19355    /// on.",
19356    ///            "type": "string"
19357    ///          },
19358    ///          "id": {
19359    ///            "description": "Identifier returned by `serve/start`.",
19360    ///            "type": "string"
19361    ///          },
19362    ///          "params": {
19363    ///            "description": "Serve configuration parameters supplied at
19364    /// startup.",
19365    ///            "type": "object",
19366    ///            "required": [
19367    ///              "fs",
19368    ///              "id",
19369    ///              "type"
19370    ///            ],
19371    ///            "properties": {
19372    ///              "fs": {
19373    ///                "type": "string"
19374    ///              },
19375    ///              "opt": {
19376    ///                "type": "object",
19377    ///                "additionalProperties": true
19378    ///              },
19379    ///              "type": {
19380    ///                "type": "string"
19381    ///              },
19382    ///              "vfsOpt": {
19383    ///                "type": "object",
19384    ///                "additionalProperties": true
19385    ///              }
19386    ///            },
19387    ///            "additionalProperties": true
19388    ///          }
19389    ///        },
19390    ///        "additionalProperties": false
19391    ///      }
19392    ///    }
19393    ///  }
19394    ///}
19395    /// ```
19396    /// </details>
19397    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19398    pub struct ServeListResponse {
19399        pub list: ::std::vec::Vec<ServeListResponseListItem>,
19400    }
19401
19402    impl ::std::convert::From<&ServeListResponse> for ServeListResponse {
19403        fn from(value: &ServeListResponse) -> Self {
19404            value.clone()
19405        }
19406    }
19407
19408    ///`ServeListResponseListItem`
19409    ///
19410    /// <details><summary>JSON schema</summary>
19411    ///
19412    /// ```json
19413    ///{
19414    ///  "type": "object",
19415    ///  "required": [
19416    ///    "addr",
19417    ///    "id"
19418    ///  ],
19419    ///  "properties": {
19420    ///    "addr": {
19421    ///      "description": "Address and port the server is listening on.",
19422    ///      "type": "string"
19423    ///    },
19424    ///    "id": {
19425    ///      "description": "Identifier returned by `serve/start`.",
19426    ///      "type": "string"
19427    ///    },
19428    ///    "params": {
19429    ///      "description": "Serve configuration parameters supplied at
19430    /// startup.",
19431    ///      "type": "object",
19432    ///      "required": [
19433    ///        "fs",
19434    ///        "id",
19435    ///        "type"
19436    ///      ],
19437    ///      "properties": {
19438    ///        "fs": {
19439    ///          "type": "string"
19440    ///        },
19441    ///        "opt": {
19442    ///          "type": "object",
19443    ///          "additionalProperties": true
19444    ///        },
19445    ///        "type": {
19446    ///          "type": "string"
19447    ///        },
19448    ///        "vfsOpt": {
19449    ///          "type": "object",
19450    ///          "additionalProperties": true
19451    ///        }
19452    ///      },
19453    ///      "additionalProperties": true
19454    ///    }
19455    ///  },
19456    ///  "additionalProperties": false
19457    ///}
19458    /// ```
19459    /// </details>
19460    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19461    #[serde(deny_unknown_fields)]
19462    pub struct ServeListResponseListItem {
19463        ///Address and port the server is listening on.
19464        pub addr: ::std::string::String,
19465        ///Identifier returned by `serve/start`.
19466        pub id: ::std::string::String,
19467        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
19468        pub params: ::std::option::Option<ServeListResponseListItemParams>,
19469    }
19470
19471    impl ::std::convert::From<&ServeListResponseListItem> for ServeListResponseListItem {
19472        fn from(value: &ServeListResponseListItem) -> Self {
19473            value.clone()
19474        }
19475    }
19476
19477    ///Serve configuration parameters supplied at startup.
19478    ///
19479    /// <details><summary>JSON schema</summary>
19480    ///
19481    /// ```json
19482    ///{
19483    ///  "description": "Serve configuration parameters supplied at startup.",
19484    ///  "type": "object",
19485    ///  "required": [
19486    ///    "fs",
19487    ///    "id",
19488    ///    "type"
19489    ///  ],
19490    ///  "properties": {
19491    ///    "fs": {
19492    ///      "type": "string"
19493    ///    },
19494    ///    "opt": {
19495    ///      "type": "object",
19496    ///      "additionalProperties": true
19497    ///    },
19498    ///    "type": {
19499    ///      "type": "string"
19500    ///    },
19501    ///    "vfsOpt": {
19502    ///      "type": "object",
19503    ///      "additionalProperties": true
19504    ///    }
19505    ///  },
19506    ///  "additionalProperties": true
19507    ///}
19508    /// ```
19509    /// </details>
19510    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19511    pub struct ServeListResponseListItemParams {
19512        pub fs: ::std::string::String,
19513        pub id: ::serde_json::Value,
19514        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
19515        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
19516        #[serde(rename = "type")]
19517        pub type_: ::std::string::String,
19518        #[serde(
19519            rename = "vfsOpt",
19520            default,
19521            skip_serializing_if = "::serde_json::Map::is_empty"
19522        )]
19523        pub vfs_opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
19524    }
19525
19526    impl ::std::convert::From<&ServeListResponseListItemParams> for ServeListResponseListItemParams {
19527        fn from(value: &ServeListResponseListItemParams) -> Self {
19528            value.clone()
19529        }
19530    }
19531
19532    ///`ServeStartPrefer`
19533    ///
19534    /// <details><summary>JSON schema</summary>
19535    ///
19536    /// ```json
19537    ///{
19538    ///  "type": "string",
19539    ///  "enum": [
19540    ///    "respond-async"
19541    ///  ]
19542    ///}
19543    /// ```
19544    /// </details>
19545    #[derive(
19546        :: serde :: Deserialize,
19547        :: serde :: Serialize,
19548        Clone,
19549        Copy,
19550        Debug,
19551        Eq,
19552        Hash,
19553        Ord,
19554        PartialEq,
19555        PartialOrd,
19556    )]
19557    pub enum ServeStartPrefer {
19558        #[serde(rename = "respond-async")]
19559        RespondAsync,
19560    }
19561
19562    impl ::std::convert::From<&Self> for ServeStartPrefer {
19563        fn from(value: &ServeStartPrefer) -> Self {
19564            value.clone()
19565        }
19566    }
19567
19568    impl ::std::fmt::Display for ServeStartPrefer {
19569        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
19570            match *self {
19571                Self::RespondAsync => f.write_str("respond-async"),
19572            }
19573        }
19574    }
19575
19576    impl ::std::str::FromStr for ServeStartPrefer {
19577        type Err = self::error::ConversionError;
19578        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19579            match value {
19580                "respond-async" => Ok(Self::RespondAsync),
19581                _ => Err("invalid value".into()),
19582            }
19583        }
19584    }
19585
19586    impl ::std::convert::TryFrom<&str> for ServeStartPrefer {
19587        type Error = self::error::ConversionError;
19588        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19589            value.parse()
19590        }
19591    }
19592
19593    impl ::std::convert::TryFrom<&::std::string::String> for ServeStartPrefer {
19594        type Error = self::error::ConversionError;
19595        fn try_from(
19596            value: &::std::string::String,
19597        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19598            value.parse()
19599        }
19600    }
19601
19602    impl ::std::convert::TryFrom<::std::string::String> for ServeStartPrefer {
19603        type Error = self::error::ConversionError;
19604        fn try_from(
19605            value: ::std::string::String,
19606        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19607            value.parse()
19608        }
19609    }
19610
19611    ///`ServeStartRequest`
19612    ///
19613    /// <details><summary>JSON schema</summary>
19614    ///
19615    /// ```json
19616    ///{
19617    ///  "type": "object",
19618    ///  "properties": {
19619    ///    "_async": {
19620    ///      "description": "Run the command asynchronously. Returns a job id
19621    /// immediately.",
19622    ///      "type": "boolean"
19623    ///    },
19624    ///    "_config": {
19625    ///      "description": "JSON encoded config overrides applied for this call
19626    /// only.",
19627    ///      "type": "string"
19628    ///    },
19629    ///    "_filter": {
19630    ///      "description": "JSON encoded filter overrides applied for this call
19631    /// only.",
19632    ///      "type": "string"
19633    ///    },
19634    ///    "_group": {
19635    ///      "description": "Assign the request to a custom stats group.",
19636    ///      "type": "string"
19637    ///    },
19638    ///    "addr": {
19639    ///      "description": "Address and port to bind the server to, such as
19640    /// `:5572` or `localhost:8080`.",
19641    ///      "type": "string"
19642    ///    },
19643    ///    "fs": {
19644    ///      "description": "Remote path that will be served.",
19645    ///      "type": "string"
19646    ///    },
19647    ///    "type": {
19648    ///      "description": "Type of server to start (e.g. `http`, `webdav`,
19649    /// `ftp`, `sftp`).",
19650    ///      "type": "string"
19651    ///    }
19652    ///  },
19653    ///  "additionalProperties": true
19654    ///}
19655    /// ```
19656    /// </details>
19657    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19658    pub struct ServeStartRequest {
19659        ///Address and port to bind the server to, such as `:5572` or
19660        /// `localhost:8080`.
19661        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
19662        pub addr: ::std::option::Option<::std::string::String>,
19663        ///Run the command asynchronously. Returns a job id immediately.
19664        #[serde(
19665            rename = "_async",
19666            default,
19667            skip_serializing_if = "::std::option::Option::is_none"
19668        )]
19669        pub async_: ::std::option::Option<bool>,
19670        ///JSON encoded config overrides applied for this call only.
19671        #[serde(
19672            rename = "_config",
19673            default,
19674            skip_serializing_if = "::std::option::Option::is_none"
19675        )]
19676        pub config: ::std::option::Option<::std::string::String>,
19677        ///JSON encoded filter overrides applied for this call only.
19678        #[serde(
19679            rename = "_filter",
19680            default,
19681            skip_serializing_if = "::std::option::Option::is_none"
19682        )]
19683        pub filter: ::std::option::Option<::std::string::String>,
19684        ///Remote path that will be served.
19685        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
19686        pub fs: ::std::option::Option<::std::string::String>,
19687        ///Assign the request to a custom stats group.
19688        #[serde(
19689            rename = "_group",
19690            default,
19691            skip_serializing_if = "::std::option::Option::is_none"
19692        )]
19693        pub group: ::std::option::Option<::std::string::String>,
19694        ///Type of server to start (e.g. `http`, `webdav`, `ftp`, `sftp`).
19695        #[serde(
19696            rename = "type",
19697            default,
19698            skip_serializing_if = "::std::option::Option::is_none"
19699        )]
19700        pub type_: ::std::option::Option<::std::string::String>,
19701    }
19702
19703    impl ::std::convert::From<&ServeStartRequest> for ServeStartRequest {
19704        fn from(value: &ServeStartRequest) -> Self {
19705            value.clone()
19706        }
19707    }
19708
19709    impl ::std::default::Default for ServeStartRequest {
19710        fn default() -> Self {
19711            Self {
19712                addr: Default::default(),
19713                async_: Default::default(),
19714                config: Default::default(),
19715                filter: Default::default(),
19716                fs: Default::default(),
19717                group: Default::default(),
19718                type_: Default::default(),
19719            }
19720        }
19721    }
19722
19723    ///`ServeStartResponse`
19724    ///
19725    /// <details><summary>JSON schema</summary>
19726    ///
19727    /// ```json
19728    ///{
19729    ///  "type": "object",
19730    ///  "required": [
19731    ///    "addr",
19732    ///    "id"
19733    ///  ],
19734    ///  "properties": {
19735    ///    "addr": {
19736    ///      "description": "Address and port the server is listening on.",
19737    ///      "type": "string"
19738    ///    },
19739    ///    "id": {
19740    ///      "description": "Identifier to pass to `serve/stop`.",
19741    ///      "type": "string"
19742    ///    }
19743    ///  }
19744    ///}
19745    /// ```
19746    /// </details>
19747    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19748    pub struct ServeStartResponse {
19749        ///Address and port the server is listening on.
19750        pub addr: ::std::string::String,
19751        ///Identifier to pass to `serve/stop`.
19752        pub id: ::std::string::String,
19753    }
19754
19755    impl ::std::convert::From<&ServeStartResponse> for ServeStartResponse {
19756        fn from(value: &ServeStartResponse) -> Self {
19757            value.clone()
19758        }
19759    }
19760
19761    ///`ServeStopPrefer`
19762    ///
19763    /// <details><summary>JSON schema</summary>
19764    ///
19765    /// ```json
19766    ///{
19767    ///  "type": "string",
19768    ///  "enum": [
19769    ///    "respond-async"
19770    ///  ]
19771    ///}
19772    /// ```
19773    /// </details>
19774    #[derive(
19775        :: serde :: Deserialize,
19776        :: serde :: Serialize,
19777        Clone,
19778        Copy,
19779        Debug,
19780        Eq,
19781        Hash,
19782        Ord,
19783        PartialEq,
19784        PartialOrd,
19785    )]
19786    pub enum ServeStopPrefer {
19787        #[serde(rename = "respond-async")]
19788        RespondAsync,
19789    }
19790
19791    impl ::std::convert::From<&Self> for ServeStopPrefer {
19792        fn from(value: &ServeStopPrefer) -> Self {
19793            value.clone()
19794        }
19795    }
19796
19797    impl ::std::fmt::Display for ServeStopPrefer {
19798        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
19799            match *self {
19800                Self::RespondAsync => f.write_str("respond-async"),
19801            }
19802        }
19803    }
19804
19805    impl ::std::str::FromStr for ServeStopPrefer {
19806        type Err = self::error::ConversionError;
19807        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19808            match value {
19809                "respond-async" => Ok(Self::RespondAsync),
19810                _ => Err("invalid value".into()),
19811            }
19812        }
19813    }
19814
19815    impl ::std::convert::TryFrom<&str> for ServeStopPrefer {
19816        type Error = self::error::ConversionError;
19817        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19818            value.parse()
19819        }
19820    }
19821
19822    impl ::std::convert::TryFrom<&::std::string::String> for ServeStopPrefer {
19823        type Error = self::error::ConversionError;
19824        fn try_from(
19825            value: &::std::string::String,
19826        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19827            value.parse()
19828        }
19829    }
19830
19831    impl ::std::convert::TryFrom<::std::string::String> for ServeStopPrefer {
19832        type Error = self::error::ConversionError;
19833        fn try_from(
19834            value: ::std::string::String,
19835        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19836            value.parse()
19837        }
19838    }
19839
19840    ///`ServeStopRequest`
19841    ///
19842    /// <details><summary>JSON schema</summary>
19843    ///
19844    /// ```json
19845    ///{
19846    ///  "type": "object",
19847    ///  "properties": {
19848    ///    "_async": {
19849    ///      "description": "Run the command asynchronously. Returns a job id
19850    /// immediately.",
19851    ///      "type": "boolean"
19852    ///    },
19853    ///    "_group": {
19854    ///      "description": "Assign the request to a custom stats group.",
19855    ///      "type": "string"
19856    ///    },
19857    ///    "id": {
19858    ///      "description": "Identifier of the running serve instance returned
19859    /// by `serve/start`.",
19860    ///      "type": "string"
19861    ///    }
19862    ///  }
19863    ///}
19864    /// ```
19865    /// </details>
19866    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
19867    pub struct ServeStopRequest {
19868        ///Run the command asynchronously. Returns a job id immediately.
19869        #[serde(
19870            rename = "_async",
19871            default,
19872            skip_serializing_if = "::std::option::Option::is_none"
19873        )]
19874        pub async_: ::std::option::Option<bool>,
19875        ///Assign the request to a custom stats group.
19876        #[serde(
19877            rename = "_group",
19878            default,
19879            skip_serializing_if = "::std::option::Option::is_none"
19880        )]
19881        pub group: ::std::option::Option<::std::string::String>,
19882        ///Identifier of the running serve instance returned by `serve/start`.
19883        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
19884        pub id: ::std::option::Option<::std::string::String>,
19885    }
19886
19887    impl ::std::convert::From<&ServeStopRequest> for ServeStopRequest {
19888        fn from(value: &ServeStopRequest) -> Self {
19889            value.clone()
19890        }
19891    }
19892
19893    impl ::std::default::Default for ServeStopRequest {
19894        fn default() -> Self {
19895            Self {
19896                async_: Default::default(),
19897                group: Default::default(),
19898                id: Default::default(),
19899            }
19900        }
19901    }
19902
19903    ///`ServeStopallPrefer`
19904    ///
19905    /// <details><summary>JSON schema</summary>
19906    ///
19907    /// ```json
19908    ///{
19909    ///  "type": "string",
19910    ///  "enum": [
19911    ///    "respond-async"
19912    ///  ]
19913    ///}
19914    /// ```
19915    /// </details>
19916    #[derive(
19917        :: serde :: Deserialize,
19918        :: serde :: Serialize,
19919        Clone,
19920        Copy,
19921        Debug,
19922        Eq,
19923        Hash,
19924        Ord,
19925        PartialEq,
19926        PartialOrd,
19927    )]
19928    pub enum ServeStopallPrefer {
19929        #[serde(rename = "respond-async")]
19930        RespondAsync,
19931    }
19932
19933    impl ::std::convert::From<&Self> for ServeStopallPrefer {
19934        fn from(value: &ServeStopallPrefer) -> Self {
19935            value.clone()
19936        }
19937    }
19938
19939    impl ::std::fmt::Display for ServeStopallPrefer {
19940        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
19941            match *self {
19942                Self::RespondAsync => f.write_str("respond-async"),
19943            }
19944        }
19945    }
19946
19947    impl ::std::str::FromStr for ServeStopallPrefer {
19948        type Err = self::error::ConversionError;
19949        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19950            match value {
19951                "respond-async" => Ok(Self::RespondAsync),
19952                _ => Err("invalid value".into()),
19953            }
19954        }
19955    }
19956
19957    impl ::std::convert::TryFrom<&str> for ServeStopallPrefer {
19958        type Error = self::error::ConversionError;
19959        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
19960            value.parse()
19961        }
19962    }
19963
19964    impl ::std::convert::TryFrom<&::std::string::String> for ServeStopallPrefer {
19965        type Error = self::error::ConversionError;
19966        fn try_from(
19967            value: &::std::string::String,
19968        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19969            value.parse()
19970        }
19971    }
19972
19973    impl ::std::convert::TryFrom<::std::string::String> for ServeStopallPrefer {
19974        type Error = self::error::ConversionError;
19975        fn try_from(
19976            value: ::std::string::String,
19977        ) -> ::std::result::Result<Self, self::error::ConversionError> {
19978            value.parse()
19979        }
19980    }
19981
19982    ///`ServeStopallRequest`
19983    ///
19984    /// <details><summary>JSON schema</summary>
19985    ///
19986    /// ```json
19987    ///{
19988    ///  "type": "object",
19989    ///  "properties": {
19990    ///    "_async": {
19991    ///      "description": "Run the command asynchronously. Returns a job id
19992    /// immediately.",
19993    ///      "type": "boolean"
19994    ///    },
19995    ///    "_group": {
19996    ///      "description": "Assign the request to a custom stats group.",
19997    ///      "type": "string"
19998    ///    }
19999    ///  }
20000    ///}
20001    /// ```
20002    /// </details>
20003    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20004    pub struct ServeStopallRequest {
20005        ///Run the command asynchronously. Returns a job id immediately.
20006        #[serde(
20007            rename = "_async",
20008            default,
20009            skip_serializing_if = "::std::option::Option::is_none"
20010        )]
20011        pub async_: ::std::option::Option<bool>,
20012        ///Assign the request to a custom stats group.
20013        #[serde(
20014            rename = "_group",
20015            default,
20016            skip_serializing_if = "::std::option::Option::is_none"
20017        )]
20018        pub group: ::std::option::Option<::std::string::String>,
20019    }
20020
20021    impl ::std::convert::From<&ServeStopallRequest> for ServeStopallRequest {
20022        fn from(value: &ServeStopallRequest) -> Self {
20023            value.clone()
20024        }
20025    }
20026
20027    impl ::std::default::Default for ServeStopallRequest {
20028        fn default() -> Self {
20029            Self {
20030                async_: Default::default(),
20031                group: Default::default(),
20032            }
20033        }
20034    }
20035
20036    ///`ServeTypesPrefer`
20037    ///
20038    /// <details><summary>JSON schema</summary>
20039    ///
20040    /// ```json
20041    ///{
20042    ///  "type": "string",
20043    ///  "enum": [
20044    ///    "respond-async"
20045    ///  ]
20046    ///}
20047    /// ```
20048    /// </details>
20049    #[derive(
20050        :: serde :: Deserialize,
20051        :: serde :: Serialize,
20052        Clone,
20053        Copy,
20054        Debug,
20055        Eq,
20056        Hash,
20057        Ord,
20058        PartialEq,
20059        PartialOrd,
20060    )]
20061    pub enum ServeTypesPrefer {
20062        #[serde(rename = "respond-async")]
20063        RespondAsync,
20064    }
20065
20066    impl ::std::convert::From<&Self> for ServeTypesPrefer {
20067        fn from(value: &ServeTypesPrefer) -> Self {
20068            value.clone()
20069        }
20070    }
20071
20072    impl ::std::fmt::Display for ServeTypesPrefer {
20073        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20074            match *self {
20075                Self::RespondAsync => f.write_str("respond-async"),
20076            }
20077        }
20078    }
20079
20080    impl ::std::str::FromStr for ServeTypesPrefer {
20081        type Err = self::error::ConversionError;
20082        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20083            match value {
20084                "respond-async" => Ok(Self::RespondAsync),
20085                _ => Err("invalid value".into()),
20086            }
20087        }
20088    }
20089
20090    impl ::std::convert::TryFrom<&str> for ServeTypesPrefer {
20091        type Error = self::error::ConversionError;
20092        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20093            value.parse()
20094        }
20095    }
20096
20097    impl ::std::convert::TryFrom<&::std::string::String> for ServeTypesPrefer {
20098        type Error = self::error::ConversionError;
20099        fn try_from(
20100            value: &::std::string::String,
20101        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20102            value.parse()
20103        }
20104    }
20105
20106    impl ::std::convert::TryFrom<::std::string::String> for ServeTypesPrefer {
20107        type Error = self::error::ConversionError;
20108        fn try_from(
20109            value: ::std::string::String,
20110        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20111            value.parse()
20112        }
20113    }
20114
20115    ///`ServeTypesRequest`
20116    ///
20117    /// <details><summary>JSON schema</summary>
20118    ///
20119    /// ```json
20120    ///{
20121    ///  "type": "object",
20122    ///  "properties": {
20123    ///    "_async": {
20124    ///      "description": "Run the command asynchronously. Returns a job id
20125    /// immediately.",
20126    ///      "type": "boolean"
20127    ///    },
20128    ///    "_group": {
20129    ///      "description": "Assign the request to a custom stats group.",
20130    ///      "type": "string"
20131    ///    }
20132    ///  }
20133    ///}
20134    /// ```
20135    /// </details>
20136    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20137    pub struct ServeTypesRequest {
20138        ///Run the command asynchronously. Returns a job id immediately.
20139        #[serde(
20140            rename = "_async",
20141            default,
20142            skip_serializing_if = "::std::option::Option::is_none"
20143        )]
20144        pub async_: ::std::option::Option<bool>,
20145        ///Assign the request to a custom stats group.
20146        #[serde(
20147            rename = "_group",
20148            default,
20149            skip_serializing_if = "::std::option::Option::is_none"
20150        )]
20151        pub group: ::std::option::Option<::std::string::String>,
20152    }
20153
20154    impl ::std::convert::From<&ServeTypesRequest> for ServeTypesRequest {
20155        fn from(value: &ServeTypesRequest) -> Self {
20156            value.clone()
20157        }
20158    }
20159
20160    impl ::std::default::Default for ServeTypesRequest {
20161        fn default() -> Self {
20162            Self {
20163                async_: Default::default(),
20164                group: Default::default(),
20165            }
20166        }
20167    }
20168
20169    ///`ServeTypesResponse`
20170    ///
20171    /// <details><summary>JSON schema</summary>
20172    ///
20173    /// ```json
20174    ///{
20175    ///  "type": "object",
20176    ///  "required": [
20177    ///    "types"
20178    ///  ],
20179    ///  "properties": {
20180    ///    "types": {
20181    ///      "type": "array",
20182    ///      "items": {
20183    ///        "type": "string"
20184    ///      }
20185    ///    }
20186    ///  }
20187    ///}
20188    /// ```
20189    /// </details>
20190    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20191    pub struct ServeTypesResponse {
20192        pub types: ::std::vec::Vec<::std::string::String>,
20193    }
20194
20195    impl ::std::convert::From<&ServeTypesResponse> for ServeTypesResponse {
20196        fn from(value: &ServeTypesResponse) -> Self {
20197            value.clone()
20198        }
20199    }
20200
20201    ///`SyncBisyncPrefer`
20202    ///
20203    /// <details><summary>JSON schema</summary>
20204    ///
20205    /// ```json
20206    ///{
20207    ///  "type": "string",
20208    ///  "enum": [
20209    ///    "respond-async"
20210    ///  ]
20211    ///}
20212    /// ```
20213    /// </details>
20214    #[derive(
20215        :: serde :: Deserialize,
20216        :: serde :: Serialize,
20217        Clone,
20218        Copy,
20219        Debug,
20220        Eq,
20221        Hash,
20222        Ord,
20223        PartialEq,
20224        PartialOrd,
20225    )]
20226    pub enum SyncBisyncPrefer {
20227        #[serde(rename = "respond-async")]
20228        RespondAsync,
20229    }
20230
20231    impl ::std::convert::From<&Self> for SyncBisyncPrefer {
20232        fn from(value: &SyncBisyncPrefer) -> Self {
20233            value.clone()
20234        }
20235    }
20236
20237    impl ::std::fmt::Display for SyncBisyncPrefer {
20238        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20239            match *self {
20240                Self::RespondAsync => f.write_str("respond-async"),
20241            }
20242        }
20243    }
20244
20245    impl ::std::str::FromStr for SyncBisyncPrefer {
20246        type Err = self::error::ConversionError;
20247        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20248            match value {
20249                "respond-async" => Ok(Self::RespondAsync),
20250                _ => Err("invalid value".into()),
20251            }
20252        }
20253    }
20254
20255    impl ::std::convert::TryFrom<&str> for SyncBisyncPrefer {
20256        type Error = self::error::ConversionError;
20257        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20258            value.parse()
20259        }
20260    }
20261
20262    impl ::std::convert::TryFrom<&::std::string::String> for SyncBisyncPrefer {
20263        type Error = self::error::ConversionError;
20264        fn try_from(
20265            value: &::std::string::String,
20266        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20267            value.parse()
20268        }
20269    }
20270
20271    impl ::std::convert::TryFrom<::std::string::String> for SyncBisyncPrefer {
20272        type Error = self::error::ConversionError;
20273        fn try_from(
20274            value: ::std::string::String,
20275        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20276            value.parse()
20277        }
20278    }
20279
20280    ///`SyncBisyncRequest`
20281    ///
20282    /// <details><summary>JSON schema</summary>
20283    ///
20284    /// ```json
20285    ///{
20286    ///  "type": "object",
20287    ///  "properties": {
20288    ///    "_async": {
20289    ///      "description": "Run the command asynchronously. Returns a job id
20290    /// immediately.",
20291    ///      "type": "boolean"
20292    ///    },
20293    ///    "_config": {
20294    ///      "description": "JSON encoded config overrides applied for this call
20295    /// only.",
20296    ///      "type": "string"
20297    ///    },
20298    ///    "_filter": {
20299    ///      "description": "JSON encoded filter overrides applied for this call
20300    /// only.",
20301    ///      "type": "string"
20302    ///    },
20303    ///    "_group": {
20304    ///      "description": "Assign the request to a custom stats group.",
20305    ///      "type": "string"
20306    ///    },
20307    ///    "backupdir1": {
20308    ///      "description": "Backup directory on the first remote for changed
20309    /// files.",
20310    ///      "type": "string"
20311    ///    },
20312    ///    "backupdir2": {
20313    ///      "description": "Backup directory on the second remote for changed
20314    /// files.",
20315    ///      "type": "string"
20316    ///    },
20317    ///    "checkAccess": {
20318    ///      "description": "Set to true to abort if `RCLONE_TEST` files are
20319    /// missing on either side.",
20320    ///      "type": "boolean"
20321    ///    },
20322    ///    "checkFilename": {
20323    ///      "description": "Override the access-check sentinel filename;
20324    /// defaults to `RCLONE_TEST`.",
20325    ///      "type": "string"
20326    ///    },
20327    ///    "checkSync": {
20328    ///      "description": "Controls final listing comparison; leave true for
20329    /// normal verification or set false to skip.",
20330    ///      "type": "boolean"
20331    ///    },
20332    ///    "createEmptySrcDirs": {
20333    ///      "description": "Set to true to mirror empty directories between the
20334    /// two paths.",
20335    ///      "type": "boolean"
20336    ///    },
20337    ///    "dryRun": {
20338    ///      "description": "Set to true to simulate the bisync run without
20339    /// making changes.",
20340    ///      "type": "boolean"
20341    ///    },
20342    ///    "filtersFile": {
20343    ///      "description": "Path to an rclone filters file applied to both
20344    /// paths.",
20345    ///      "type": "string"
20346    ///    },
20347    ///    "force": {
20348    ///      "description": "Set to true to bypass the `maxDelete` safety
20349    /// check.",
20350    ///      "type": "boolean"
20351    ///    },
20352    ///    "ignoreListingChecksum": {
20353    ///      "description": "Set to true to ignore checksum differences when
20354    /// comparing listings.",
20355    ///      "type": "boolean"
20356    ///    },
20357    ///    "maxDelete": {
20358    ///      "description": "Abort the run if deletions exceed this percentage
20359    /// (default 50).",
20360    ///      "type": "number"
20361    ///    },
20362    ///    "noCleanup": {
20363    ///      "description": "Set to true to keep bisync working files after
20364    /// completion.",
20365    ///      "type": "boolean"
20366    ///    },
20367    ///    "path1": {
20368    ///      "description": "First remote directory, e.g. `drive:path1`.",
20369    ///      "type": "string"
20370    ///    },
20371    ///    "path2": {
20372    ///      "description": "Second remote directory, e.g. `drive:path2`.",
20373    ///      "type": "string"
20374    ///    },
20375    ///    "removeEmptyDirs": {
20376    ///      "description": "Set to true to remove empty directories during
20377    /// cleanup.",
20378    ///      "type": "boolean"
20379    ///    },
20380    ///    "resilient": {
20381    ///      "description": "Set to true to allow retrying after certain
20382    /// recoverable errors.",
20383    ///      "type": "boolean"
20384    ///    },
20385    ///    "resync": {
20386    ///      "description": "Set to true to perform a one-time resync,
20387    /// rebuilding bisync history.",
20388    ///      "type": "boolean"
20389    ///    },
20390    ///    "workdir": {
20391    ///      "description": "Directory path used to store bisync working
20392    /// files.",
20393    ///      "type": "string"
20394    ///    }
20395    ///  }
20396    ///}
20397    /// ```
20398    /// </details>
20399    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20400    pub struct SyncBisyncRequest {
20401        ///Run the command asynchronously. Returns a job id immediately.
20402        #[serde(
20403            rename = "_async",
20404            default,
20405            skip_serializing_if = "::std::option::Option::is_none"
20406        )]
20407        pub async_: ::std::option::Option<bool>,
20408        ///Backup directory on the first remote for changed files.
20409        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20410        pub backupdir1: ::std::option::Option<::std::string::String>,
20411        ///Backup directory on the second remote for changed files.
20412        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20413        pub backupdir2: ::std::option::Option<::std::string::String>,
20414        ///Set to true to abort if `RCLONE_TEST` files are missing on either
20415        /// side.
20416        #[serde(
20417            rename = "checkAccess",
20418            default,
20419            skip_serializing_if = "::std::option::Option::is_none"
20420        )]
20421        pub check_access: ::std::option::Option<bool>,
20422        ///Override the access-check sentinel filename; defaults to
20423        /// `RCLONE_TEST`.
20424        #[serde(
20425            rename = "checkFilename",
20426            default,
20427            skip_serializing_if = "::std::option::Option::is_none"
20428        )]
20429        pub check_filename: ::std::option::Option<::std::string::String>,
20430        ///Controls final listing comparison; leave true for normal
20431        /// verification or set false to skip.
20432        #[serde(
20433            rename = "checkSync",
20434            default,
20435            skip_serializing_if = "::std::option::Option::is_none"
20436        )]
20437        pub check_sync: ::std::option::Option<bool>,
20438        ///JSON encoded config overrides applied for this call only.
20439        #[serde(
20440            rename = "_config",
20441            default,
20442            skip_serializing_if = "::std::option::Option::is_none"
20443        )]
20444        pub config: ::std::option::Option<::std::string::String>,
20445        ///Set to true to mirror empty directories between the two paths.
20446        #[serde(
20447            rename = "createEmptySrcDirs",
20448            default,
20449            skip_serializing_if = "::std::option::Option::is_none"
20450        )]
20451        pub create_empty_src_dirs: ::std::option::Option<bool>,
20452        ///Set to true to simulate the bisync run without making changes.
20453        #[serde(
20454            rename = "dryRun",
20455            default,
20456            skip_serializing_if = "::std::option::Option::is_none"
20457        )]
20458        pub dry_run: ::std::option::Option<bool>,
20459        ///JSON encoded filter overrides applied for this call only.
20460        #[serde(
20461            rename = "_filter",
20462            default,
20463            skip_serializing_if = "::std::option::Option::is_none"
20464        )]
20465        pub filter: ::std::option::Option<::std::string::String>,
20466        ///Path to an rclone filters file applied to both paths.
20467        #[serde(
20468            rename = "filtersFile",
20469            default,
20470            skip_serializing_if = "::std::option::Option::is_none"
20471        )]
20472        pub filters_file: ::std::option::Option<::std::string::String>,
20473        ///Set to true to bypass the `maxDelete` safety check.
20474        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20475        pub force: ::std::option::Option<bool>,
20476        ///Assign the request to a custom stats group.
20477        #[serde(
20478            rename = "_group",
20479            default,
20480            skip_serializing_if = "::std::option::Option::is_none"
20481        )]
20482        pub group: ::std::option::Option<::std::string::String>,
20483        ///Set to true to ignore checksum differences when comparing listings.
20484        #[serde(
20485            rename = "ignoreListingChecksum",
20486            default,
20487            skip_serializing_if = "::std::option::Option::is_none"
20488        )]
20489        pub ignore_listing_checksum: ::std::option::Option<bool>,
20490        #[serde(
20491            rename = "maxDelete",
20492            default,
20493            skip_serializing_if = "::std::option::Option::is_none"
20494        )]
20495        pub max_delete: ::std::option::Option<f64>,
20496        ///Set to true to keep bisync working files after completion.
20497        #[serde(
20498            rename = "noCleanup",
20499            default,
20500            skip_serializing_if = "::std::option::Option::is_none"
20501        )]
20502        pub no_cleanup: ::std::option::Option<bool>,
20503        ///First remote directory, e.g. `drive:path1`.
20504        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20505        pub path1: ::std::option::Option<::std::string::String>,
20506        ///Second remote directory, e.g. `drive:path2`.
20507        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20508        pub path2: ::std::option::Option<::std::string::String>,
20509        ///Set to true to remove empty directories during cleanup.
20510        #[serde(
20511            rename = "removeEmptyDirs",
20512            default,
20513            skip_serializing_if = "::std::option::Option::is_none"
20514        )]
20515        pub remove_empty_dirs: ::std::option::Option<bool>,
20516        ///Set to true to allow retrying after certain recoverable errors.
20517        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20518        pub resilient: ::std::option::Option<bool>,
20519        ///Set to true to perform a one-time resync, rebuilding bisync history.
20520        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20521        pub resync: ::std::option::Option<bool>,
20522        ///Directory path used to store bisync working files.
20523        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
20524        pub workdir: ::std::option::Option<::std::string::String>,
20525    }
20526
20527    impl ::std::convert::From<&SyncBisyncRequest> for SyncBisyncRequest {
20528        fn from(value: &SyncBisyncRequest) -> Self {
20529            value.clone()
20530        }
20531    }
20532
20533    impl ::std::default::Default for SyncBisyncRequest {
20534        fn default() -> Self {
20535            Self {
20536                async_: Default::default(),
20537                backupdir1: Default::default(),
20538                backupdir2: Default::default(),
20539                check_access: Default::default(),
20540                check_filename: Default::default(),
20541                check_sync: Default::default(),
20542                config: Default::default(),
20543                create_empty_src_dirs: Default::default(),
20544                dry_run: Default::default(),
20545                filter: Default::default(),
20546                filters_file: Default::default(),
20547                force: Default::default(),
20548                group: Default::default(),
20549                ignore_listing_checksum: Default::default(),
20550                max_delete: Default::default(),
20551                no_cleanup: Default::default(),
20552                path1: Default::default(),
20553                path2: Default::default(),
20554                remove_empty_dirs: Default::default(),
20555                resilient: Default::default(),
20556                resync: Default::default(),
20557                workdir: Default::default(),
20558            }
20559        }
20560    }
20561
20562    ///`SyncBisyncResponse`
20563    ///
20564    /// <details><summary>JSON schema</summary>
20565    ///
20566    /// ```json
20567    ///{
20568    ///  "type": "object",
20569    ///  "required": [
20570    ///    "basePath",
20571    ///    "listing1",
20572    ///    "listing2",
20573    ///    "logFile",
20574    ///    "output",
20575    ///    "session",
20576    ///    "workDir"
20577    ///  ],
20578    ///  "properties": {
20579    ///    "basePath": {
20580    ///      "description": "Base path for listing files.",
20581    ///      "type": "string"
20582    ///    },
20583    ///    "listing1": {
20584    ///      "description": "Path to the Path1 listing file.",
20585    ///      "type": "string"
20586    ///    },
20587    ///    "listing2": {
20588    ///      "description": "Path to the Path2 listing file.",
20589    ///      "type": "string"
20590    ///    },
20591    ///    "logFile": {
20592    ///      "description": "Path to the log file.",
20593    ///      "type": "string"
20594    ///    },
20595    ///    "output": {
20596    ///      "description": "Captured output from the bisync operation.",
20597    ///      "type": "string"
20598    ///    },
20599    ///    "session": {
20600    ///      "description": "Session name derived from the two filesystems.",
20601    ///      "type": "string"
20602    ///    },
20603    ///    "workDir": {
20604    ///      "description": "Absolute path to the bisync working directory.",
20605    ///      "type": "string"
20606    ///    }
20607    ///  }
20608    ///}
20609    /// ```
20610    /// </details>
20611    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20612    pub struct SyncBisyncResponse {
20613        ///Base path for listing files.
20614        #[serde(rename = "basePath")]
20615        pub base_path: ::std::string::String,
20616        ///Path to the Path1 listing file.
20617        pub listing1: ::std::string::String,
20618        ///Path to the Path2 listing file.
20619        pub listing2: ::std::string::String,
20620        ///Path to the log file.
20621        #[serde(rename = "logFile")]
20622        pub log_file: ::std::string::String,
20623        ///Captured output from the bisync operation.
20624        pub output: ::std::string::String,
20625        ///Session name derived from the two filesystems.
20626        pub session: ::std::string::String,
20627        ///Absolute path to the bisync working directory.
20628        #[serde(rename = "workDir")]
20629        pub work_dir: ::std::string::String,
20630    }
20631
20632    impl ::std::convert::From<&SyncBisyncResponse> for SyncBisyncResponse {
20633        fn from(value: &SyncBisyncResponse) -> Self {
20634            value.clone()
20635        }
20636    }
20637
20638    ///`SyncCopyPrefer`
20639    ///
20640    /// <details><summary>JSON schema</summary>
20641    ///
20642    /// ```json
20643    ///{
20644    ///  "type": "string",
20645    ///  "enum": [
20646    ///    "respond-async"
20647    ///  ]
20648    ///}
20649    /// ```
20650    /// </details>
20651    #[derive(
20652        :: serde :: Deserialize,
20653        :: serde :: Serialize,
20654        Clone,
20655        Copy,
20656        Debug,
20657        Eq,
20658        Hash,
20659        Ord,
20660        PartialEq,
20661        PartialOrd,
20662    )]
20663    pub enum SyncCopyPrefer {
20664        #[serde(rename = "respond-async")]
20665        RespondAsync,
20666    }
20667
20668    impl ::std::convert::From<&Self> for SyncCopyPrefer {
20669        fn from(value: &SyncCopyPrefer) -> Self {
20670            value.clone()
20671        }
20672    }
20673
20674    impl ::std::fmt::Display for SyncCopyPrefer {
20675        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20676            match *self {
20677                Self::RespondAsync => f.write_str("respond-async"),
20678            }
20679        }
20680    }
20681
20682    impl ::std::str::FromStr for SyncCopyPrefer {
20683        type Err = self::error::ConversionError;
20684        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20685            match value {
20686                "respond-async" => Ok(Self::RespondAsync),
20687                _ => Err("invalid value".into()),
20688            }
20689        }
20690    }
20691
20692    impl ::std::convert::TryFrom<&str> for SyncCopyPrefer {
20693        type Error = self::error::ConversionError;
20694        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20695            value.parse()
20696        }
20697    }
20698
20699    impl ::std::convert::TryFrom<&::std::string::String> for SyncCopyPrefer {
20700        type Error = self::error::ConversionError;
20701        fn try_from(
20702            value: &::std::string::String,
20703        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20704            value.parse()
20705        }
20706    }
20707
20708    impl ::std::convert::TryFrom<::std::string::String> for SyncCopyPrefer {
20709        type Error = self::error::ConversionError;
20710        fn try_from(
20711            value: ::std::string::String,
20712        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20713            value.parse()
20714        }
20715    }
20716
20717    ///`SyncCopyRequest`
20718    ///
20719    /// <details><summary>JSON schema</summary>
20720    ///
20721    /// ```json
20722    ///{
20723    ///  "type": "object",
20724    ///  "properties": {
20725    ///    "_async": {
20726    ///      "description": "Run the command asynchronously. Returns a job id
20727    /// immediately.",
20728    ///      "type": "boolean"
20729    ///    },
20730    ///    "_config": {
20731    ///      "description": "JSON encoded config overrides applied for this call
20732    /// only.",
20733    ///      "type": "string"
20734    ///    },
20735    ///    "_filter": {
20736    ///      "description": "JSON encoded filter overrides applied for this call
20737    /// only.",
20738    ///      "type": "string"
20739    ///    },
20740    ///    "_group": {
20741    ///      "description": "Assign the request to a custom stats group.",
20742    ///      "type": "string"
20743    ///    },
20744    ///    "createEmptySrcDirs": {
20745    ///      "description": "Set to true to replicate empty source directories
20746    /// on the destination.",
20747    ///      "type": "boolean"
20748    ///    },
20749    ///    "dstFs": {
20750    ///      "description": "Destination remote path to copy to.",
20751    ///      "type": "string"
20752    ///    },
20753    ///    "srcFs": {
20754    ///      "description": "Source remote path to copy from.",
20755    ///      "type": "string"
20756    ///    }
20757    ///  }
20758    ///}
20759    /// ```
20760    /// </details>
20761    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20762    pub struct SyncCopyRequest {
20763        ///Run the command asynchronously. Returns a job id immediately.
20764        #[serde(
20765            rename = "_async",
20766            default,
20767            skip_serializing_if = "::std::option::Option::is_none"
20768        )]
20769        pub async_: ::std::option::Option<bool>,
20770        ///JSON encoded config overrides applied for this call only.
20771        #[serde(
20772            rename = "_config",
20773            default,
20774            skip_serializing_if = "::std::option::Option::is_none"
20775        )]
20776        pub config: ::std::option::Option<::std::string::String>,
20777        ///Set to true to replicate empty source directories on the
20778        /// destination.
20779        #[serde(
20780            rename = "createEmptySrcDirs",
20781            default,
20782            skip_serializing_if = "::std::option::Option::is_none"
20783        )]
20784        pub create_empty_src_dirs: ::std::option::Option<bool>,
20785        ///Destination remote path to copy to.
20786        #[serde(
20787            rename = "dstFs",
20788            default,
20789            skip_serializing_if = "::std::option::Option::is_none"
20790        )]
20791        pub dst_fs: ::std::option::Option<::std::string::String>,
20792        ///JSON encoded filter overrides applied for this call only.
20793        #[serde(
20794            rename = "_filter",
20795            default,
20796            skip_serializing_if = "::std::option::Option::is_none"
20797        )]
20798        pub filter: ::std::option::Option<::std::string::String>,
20799        ///Assign the request to a custom stats group.
20800        #[serde(
20801            rename = "_group",
20802            default,
20803            skip_serializing_if = "::std::option::Option::is_none"
20804        )]
20805        pub group: ::std::option::Option<::std::string::String>,
20806        ///Source remote path to copy from.
20807        #[serde(
20808            rename = "srcFs",
20809            default,
20810            skip_serializing_if = "::std::option::Option::is_none"
20811        )]
20812        pub src_fs: ::std::option::Option<::std::string::String>,
20813    }
20814
20815    impl ::std::convert::From<&SyncCopyRequest> for SyncCopyRequest {
20816        fn from(value: &SyncCopyRequest) -> Self {
20817            value.clone()
20818        }
20819    }
20820
20821    impl ::std::default::Default for SyncCopyRequest {
20822        fn default() -> Self {
20823            Self {
20824                async_: Default::default(),
20825                config: Default::default(),
20826                create_empty_src_dirs: Default::default(),
20827                dst_fs: Default::default(),
20828                filter: Default::default(),
20829                group: Default::default(),
20830                src_fs: Default::default(),
20831            }
20832        }
20833    }
20834
20835    ///`SyncMovePrefer`
20836    ///
20837    /// <details><summary>JSON schema</summary>
20838    ///
20839    /// ```json
20840    ///{
20841    ///  "type": "string",
20842    ///  "enum": [
20843    ///    "respond-async"
20844    ///  ]
20845    ///}
20846    /// ```
20847    /// </details>
20848    #[derive(
20849        :: serde :: Deserialize,
20850        :: serde :: Serialize,
20851        Clone,
20852        Copy,
20853        Debug,
20854        Eq,
20855        Hash,
20856        Ord,
20857        PartialEq,
20858        PartialOrd,
20859    )]
20860    pub enum SyncMovePrefer {
20861        #[serde(rename = "respond-async")]
20862        RespondAsync,
20863    }
20864
20865    impl ::std::convert::From<&Self> for SyncMovePrefer {
20866        fn from(value: &SyncMovePrefer) -> Self {
20867            value.clone()
20868        }
20869    }
20870
20871    impl ::std::fmt::Display for SyncMovePrefer {
20872        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20873            match *self {
20874                Self::RespondAsync => f.write_str("respond-async"),
20875            }
20876        }
20877    }
20878
20879    impl ::std::str::FromStr for SyncMovePrefer {
20880        type Err = self::error::ConversionError;
20881        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20882            match value {
20883                "respond-async" => Ok(Self::RespondAsync),
20884                _ => Err("invalid value".into()),
20885            }
20886        }
20887    }
20888
20889    impl ::std::convert::TryFrom<&str> for SyncMovePrefer {
20890        type Error = self::error::ConversionError;
20891        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
20892            value.parse()
20893        }
20894    }
20895
20896    impl ::std::convert::TryFrom<&::std::string::String> for SyncMovePrefer {
20897        type Error = self::error::ConversionError;
20898        fn try_from(
20899            value: &::std::string::String,
20900        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20901            value.parse()
20902        }
20903    }
20904
20905    impl ::std::convert::TryFrom<::std::string::String> for SyncMovePrefer {
20906        type Error = self::error::ConversionError;
20907        fn try_from(
20908            value: ::std::string::String,
20909        ) -> ::std::result::Result<Self, self::error::ConversionError> {
20910            value.parse()
20911        }
20912    }
20913
20914    ///`SyncMoveRequest`
20915    ///
20916    /// <details><summary>JSON schema</summary>
20917    ///
20918    /// ```json
20919    ///{
20920    ///  "type": "object",
20921    ///  "properties": {
20922    ///    "_async": {
20923    ///      "description": "Run the command asynchronously. Returns a job id
20924    /// immediately.",
20925    ///      "type": "boolean"
20926    ///    },
20927    ///    "_config": {
20928    ///      "description": "JSON encoded config overrides applied for this call
20929    /// only.",
20930    ///      "type": "string"
20931    ///    },
20932    ///    "_filter": {
20933    ///      "description": "JSON encoded filter overrides applied for this call
20934    /// only.",
20935    ///      "type": "string"
20936    ///    },
20937    ///    "_group": {
20938    ///      "description": "Assign the request to a custom stats group.",
20939    ///      "type": "string"
20940    ///    },
20941    ///    "createEmptySrcDirs": {
20942    ///      "description": "Set to true to create empty source directories on
20943    /// the destination.",
20944    ///      "type": "boolean"
20945    ///    },
20946    ///    "deleteEmptySrcDirs": {
20947    ///      "description": "Set to true to delete empty directories from the
20948    /// source after the move completes.",
20949    ///      "type": "boolean"
20950    ///    },
20951    ///    "dstFs": {
20952    ///      "description": "Destination remote path that will receive moved
20953    /// files.",
20954    ///      "type": "string"
20955    ///    },
20956    ///    "srcFs": {
20957    ///      "description": "Source remote path whose contents will be moved.",
20958    ///      "type": "string"
20959    ///    }
20960    ///  }
20961    ///}
20962    /// ```
20963    /// </details>
20964    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
20965    pub struct SyncMoveRequest {
20966        ///Run the command asynchronously. Returns a job id immediately.
20967        #[serde(
20968            rename = "_async",
20969            default,
20970            skip_serializing_if = "::std::option::Option::is_none"
20971        )]
20972        pub async_: ::std::option::Option<bool>,
20973        ///JSON encoded config overrides applied for this call only.
20974        #[serde(
20975            rename = "_config",
20976            default,
20977            skip_serializing_if = "::std::option::Option::is_none"
20978        )]
20979        pub config: ::std::option::Option<::std::string::String>,
20980        ///Set to true to create empty source directories on the destination.
20981        #[serde(
20982            rename = "createEmptySrcDirs",
20983            default,
20984            skip_serializing_if = "::std::option::Option::is_none"
20985        )]
20986        pub create_empty_src_dirs: ::std::option::Option<bool>,
20987        ///Set to true to delete empty directories from the source after the
20988        /// move completes.
20989        #[serde(
20990            rename = "deleteEmptySrcDirs",
20991            default,
20992            skip_serializing_if = "::std::option::Option::is_none"
20993        )]
20994        pub delete_empty_src_dirs: ::std::option::Option<bool>,
20995        ///Destination remote path that will receive moved files.
20996        #[serde(
20997            rename = "dstFs",
20998            default,
20999            skip_serializing_if = "::std::option::Option::is_none"
21000        )]
21001        pub dst_fs: ::std::option::Option<::std::string::String>,
21002        ///JSON encoded filter overrides applied for this call only.
21003        #[serde(
21004            rename = "_filter",
21005            default,
21006            skip_serializing_if = "::std::option::Option::is_none"
21007        )]
21008        pub filter: ::std::option::Option<::std::string::String>,
21009        ///Assign the request to a custom stats group.
21010        #[serde(
21011            rename = "_group",
21012            default,
21013            skip_serializing_if = "::std::option::Option::is_none"
21014        )]
21015        pub group: ::std::option::Option<::std::string::String>,
21016        ///Source remote path whose contents will be moved.
21017        #[serde(
21018            rename = "srcFs",
21019            default,
21020            skip_serializing_if = "::std::option::Option::is_none"
21021        )]
21022        pub src_fs: ::std::option::Option<::std::string::String>,
21023    }
21024
21025    impl ::std::convert::From<&SyncMoveRequest> for SyncMoveRequest {
21026        fn from(value: &SyncMoveRequest) -> Self {
21027            value.clone()
21028        }
21029    }
21030
21031    impl ::std::default::Default for SyncMoveRequest {
21032        fn default() -> Self {
21033            Self {
21034                async_: Default::default(),
21035                config: Default::default(),
21036                create_empty_src_dirs: Default::default(),
21037                delete_empty_src_dirs: Default::default(),
21038                dst_fs: Default::default(),
21039                filter: Default::default(),
21040                group: Default::default(),
21041                src_fs: Default::default(),
21042            }
21043        }
21044    }
21045
21046    ///`SyncSyncPrefer`
21047    ///
21048    /// <details><summary>JSON schema</summary>
21049    ///
21050    /// ```json
21051    ///{
21052    ///  "type": "string",
21053    ///  "enum": [
21054    ///    "respond-async"
21055    ///  ]
21056    ///}
21057    /// ```
21058    /// </details>
21059    #[derive(
21060        :: serde :: Deserialize,
21061        :: serde :: Serialize,
21062        Clone,
21063        Copy,
21064        Debug,
21065        Eq,
21066        Hash,
21067        Ord,
21068        PartialEq,
21069        PartialOrd,
21070    )]
21071    pub enum SyncSyncPrefer {
21072        #[serde(rename = "respond-async")]
21073        RespondAsync,
21074    }
21075
21076    impl ::std::convert::From<&Self> for SyncSyncPrefer {
21077        fn from(value: &SyncSyncPrefer) -> Self {
21078            value.clone()
21079        }
21080    }
21081
21082    impl ::std::fmt::Display for SyncSyncPrefer {
21083        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21084            match *self {
21085                Self::RespondAsync => f.write_str("respond-async"),
21086            }
21087        }
21088    }
21089
21090    impl ::std::str::FromStr for SyncSyncPrefer {
21091        type Err = self::error::ConversionError;
21092        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21093            match value {
21094                "respond-async" => Ok(Self::RespondAsync),
21095                _ => Err("invalid value".into()),
21096            }
21097        }
21098    }
21099
21100    impl ::std::convert::TryFrom<&str> for SyncSyncPrefer {
21101        type Error = self::error::ConversionError;
21102        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21103            value.parse()
21104        }
21105    }
21106
21107    impl ::std::convert::TryFrom<&::std::string::String> for SyncSyncPrefer {
21108        type Error = self::error::ConversionError;
21109        fn try_from(
21110            value: &::std::string::String,
21111        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21112            value.parse()
21113        }
21114    }
21115
21116    impl ::std::convert::TryFrom<::std::string::String> for SyncSyncPrefer {
21117        type Error = self::error::ConversionError;
21118        fn try_from(
21119            value: ::std::string::String,
21120        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21121            value.parse()
21122        }
21123    }
21124
21125    ///`SyncSyncRequest`
21126    ///
21127    /// <details><summary>JSON schema</summary>
21128    ///
21129    /// ```json
21130    ///{
21131    ///  "type": "object",
21132    ///  "properties": {
21133    ///    "_async": {
21134    ///      "description": "Run the command asynchronously. Returns a job id
21135    /// immediately.",
21136    ///      "type": "boolean"
21137    ///    },
21138    ///    "_config": {
21139    ///      "description": "JSON encoded config overrides applied for this call
21140    /// only.",
21141    ///      "type": "string"
21142    ///    },
21143    ///    "_filter": {
21144    ///      "description": "JSON encoded filter overrides applied for this call
21145    /// only.",
21146    ///      "type": "string"
21147    ///    },
21148    ///    "_group": {
21149    ///      "description": "Assign the request to a custom stats group.",
21150    ///      "type": "string"
21151    ///    },
21152    ///    "createEmptySrcDirs": {
21153    ///      "description": "Set to true to create empty source directories on
21154    /// the destination.",
21155    ///      "type": "boolean"
21156    ///    },
21157    ///    "dstFs": {
21158    ///      "description": "Destination remote path to sync to, e.g.
21159    /// `drive:dst`.",
21160    ///      "type": "string"
21161    ///    },
21162    ///    "srcFs": {
21163    ///      "description": "Source remote path to sync from, e.g.
21164    /// `drive:src`.",
21165    ///      "type": "string"
21166    ///    }
21167    ///  }
21168    ///}
21169    /// ```
21170    /// </details>
21171    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21172    pub struct SyncSyncRequest {
21173        ///Run the command asynchronously. Returns a job id immediately.
21174        #[serde(
21175            rename = "_async",
21176            default,
21177            skip_serializing_if = "::std::option::Option::is_none"
21178        )]
21179        pub async_: ::std::option::Option<bool>,
21180        ///JSON encoded config overrides applied for this call only.
21181        #[serde(
21182            rename = "_config",
21183            default,
21184            skip_serializing_if = "::std::option::Option::is_none"
21185        )]
21186        pub config: ::std::option::Option<::std::string::String>,
21187        ///Set to true to create empty source directories on the destination.
21188        #[serde(
21189            rename = "createEmptySrcDirs",
21190            default,
21191            skip_serializing_if = "::std::option::Option::is_none"
21192        )]
21193        pub create_empty_src_dirs: ::std::option::Option<bool>,
21194        ///Destination remote path to sync to, e.g. `drive:dst`.
21195        #[serde(
21196            rename = "dstFs",
21197            default,
21198            skip_serializing_if = "::std::option::Option::is_none"
21199        )]
21200        pub dst_fs: ::std::option::Option<::std::string::String>,
21201        ///JSON encoded filter overrides applied for this call only.
21202        #[serde(
21203            rename = "_filter",
21204            default,
21205            skip_serializing_if = "::std::option::Option::is_none"
21206        )]
21207        pub filter: ::std::option::Option<::std::string::String>,
21208        ///Assign the request to a custom stats group.
21209        #[serde(
21210            rename = "_group",
21211            default,
21212            skip_serializing_if = "::std::option::Option::is_none"
21213        )]
21214        pub group: ::std::option::Option<::std::string::String>,
21215        ///Source remote path to sync from, e.g. `drive:src`.
21216        #[serde(
21217            rename = "srcFs",
21218            default,
21219            skip_serializing_if = "::std::option::Option::is_none"
21220        )]
21221        pub src_fs: ::std::option::Option<::std::string::String>,
21222    }
21223
21224    impl ::std::convert::From<&SyncSyncRequest> for SyncSyncRequest {
21225        fn from(value: &SyncSyncRequest) -> Self {
21226            value.clone()
21227        }
21228    }
21229
21230    impl ::std::default::Default for SyncSyncRequest {
21231        fn default() -> Self {
21232            Self {
21233                async_: Default::default(),
21234                config: Default::default(),
21235                create_empty_src_dirs: Default::default(),
21236                dst_fs: Default::default(),
21237                filter: Default::default(),
21238                group: Default::default(),
21239                src_fs: Default::default(),
21240            }
21241        }
21242    }
21243
21244    ///`VfsForgetPrefer`
21245    ///
21246    /// <details><summary>JSON schema</summary>
21247    ///
21248    /// ```json
21249    ///{
21250    ///  "type": "string",
21251    ///  "enum": [
21252    ///    "respond-async"
21253    ///  ]
21254    ///}
21255    /// ```
21256    /// </details>
21257    #[derive(
21258        :: serde :: Deserialize,
21259        :: serde :: Serialize,
21260        Clone,
21261        Copy,
21262        Debug,
21263        Eq,
21264        Hash,
21265        Ord,
21266        PartialEq,
21267        PartialOrd,
21268    )]
21269    pub enum VfsForgetPrefer {
21270        #[serde(rename = "respond-async")]
21271        RespondAsync,
21272    }
21273
21274    impl ::std::convert::From<&Self> for VfsForgetPrefer {
21275        fn from(value: &VfsForgetPrefer) -> Self {
21276            value.clone()
21277        }
21278    }
21279
21280    impl ::std::fmt::Display for VfsForgetPrefer {
21281        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21282            match *self {
21283                Self::RespondAsync => f.write_str("respond-async"),
21284            }
21285        }
21286    }
21287
21288    impl ::std::str::FromStr for VfsForgetPrefer {
21289        type Err = self::error::ConversionError;
21290        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21291            match value {
21292                "respond-async" => Ok(Self::RespondAsync),
21293                _ => Err("invalid value".into()),
21294            }
21295        }
21296    }
21297
21298    impl ::std::convert::TryFrom<&str> for VfsForgetPrefer {
21299        type Error = self::error::ConversionError;
21300        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21301            value.parse()
21302        }
21303    }
21304
21305    impl ::std::convert::TryFrom<&::std::string::String> for VfsForgetPrefer {
21306        type Error = self::error::ConversionError;
21307        fn try_from(
21308            value: &::std::string::String,
21309        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21310            value.parse()
21311        }
21312    }
21313
21314    impl ::std::convert::TryFrom<::std::string::String> for VfsForgetPrefer {
21315        type Error = self::error::ConversionError;
21316        fn try_from(
21317            value: ::std::string::String,
21318        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21319            value.parse()
21320        }
21321    }
21322
21323    ///`VfsForgetRequest`
21324    ///
21325    /// <details><summary>JSON schema</summary>
21326    ///
21327    /// ```json
21328    ///{
21329    ///  "type": "object",
21330    ///  "properties": {
21331    ///    "_async": {
21332    ///      "description": "Run the command asynchronously. Returns a job id
21333    /// immediately.",
21334    ///      "type": "boolean"
21335    ///    },
21336    ///    "_group": {
21337    ///      "description": "Assign the request to a custom stats group.",
21338    ///      "type": "string"
21339    ///    },
21340    ///    "fs": {
21341    ///      "description": "Optional VFS identifier to target; required when
21342    /// more than one VFS is active.",
21343    ///      "type": "string"
21344    ///    }
21345    ///  },
21346    ///  "additionalProperties": true
21347    ///}
21348    /// ```
21349    /// </details>
21350    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21351    pub struct VfsForgetRequest {
21352        ///Run the command asynchronously. Returns a job id immediately.
21353        #[serde(
21354            rename = "_async",
21355            default,
21356            skip_serializing_if = "::std::option::Option::is_none"
21357        )]
21358        pub async_: ::std::option::Option<bool>,
21359        ///Optional VFS identifier to target; required when more than one VFS
21360        /// is active.
21361        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21362        pub fs: ::std::option::Option<::std::string::String>,
21363        ///Assign the request to a custom stats group.
21364        #[serde(
21365            rename = "_group",
21366            default,
21367            skip_serializing_if = "::std::option::Option::is_none"
21368        )]
21369        pub group: ::std::option::Option<::std::string::String>,
21370    }
21371
21372    impl ::std::convert::From<&VfsForgetRequest> for VfsForgetRequest {
21373        fn from(value: &VfsForgetRequest) -> Self {
21374            value.clone()
21375        }
21376    }
21377
21378    impl ::std::default::Default for VfsForgetRequest {
21379        fn default() -> Self {
21380            Self {
21381                async_: Default::default(),
21382                fs: Default::default(),
21383                group: Default::default(),
21384            }
21385        }
21386    }
21387
21388    ///`VfsForgetResponse`
21389    ///
21390    /// <details><summary>JSON schema</summary>
21391    ///
21392    /// ```json
21393    ///{
21394    ///  "type": "object",
21395    ///  "required": [
21396    ///    "forgotten"
21397    ///  ],
21398    ///  "properties": {
21399    ///    "forgotten": {
21400    ///      "description": "Paths that were successfully forgotten.",
21401    ///      "type": "array",
21402    ///      "items": {
21403    ///        "type": "string"
21404    ///      }
21405    ///    }
21406    ///  }
21407    ///}
21408    /// ```
21409    /// </details>
21410    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21411    pub struct VfsForgetResponse {
21412        ///Paths that were successfully forgotten.
21413        pub forgotten: ::std::vec::Vec<::std::string::String>,
21414    }
21415
21416    impl ::std::convert::From<&VfsForgetResponse> for VfsForgetResponse {
21417        fn from(value: &VfsForgetResponse) -> Self {
21418            value.clone()
21419        }
21420    }
21421
21422    ///`VfsListPrefer`
21423    ///
21424    /// <details><summary>JSON schema</summary>
21425    ///
21426    /// ```json
21427    ///{
21428    ///  "type": "string",
21429    ///  "enum": [
21430    ///    "respond-async"
21431    ///  ]
21432    ///}
21433    /// ```
21434    /// </details>
21435    #[derive(
21436        :: serde :: Deserialize,
21437        :: serde :: Serialize,
21438        Clone,
21439        Copy,
21440        Debug,
21441        Eq,
21442        Hash,
21443        Ord,
21444        PartialEq,
21445        PartialOrd,
21446    )]
21447    pub enum VfsListPrefer {
21448        #[serde(rename = "respond-async")]
21449        RespondAsync,
21450    }
21451
21452    impl ::std::convert::From<&Self> for VfsListPrefer {
21453        fn from(value: &VfsListPrefer) -> Self {
21454            value.clone()
21455        }
21456    }
21457
21458    impl ::std::fmt::Display for VfsListPrefer {
21459        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21460            match *self {
21461                Self::RespondAsync => f.write_str("respond-async"),
21462            }
21463        }
21464    }
21465
21466    impl ::std::str::FromStr for VfsListPrefer {
21467        type Err = self::error::ConversionError;
21468        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21469            match value {
21470                "respond-async" => Ok(Self::RespondAsync),
21471                _ => Err("invalid value".into()),
21472            }
21473        }
21474    }
21475
21476    impl ::std::convert::TryFrom<&str> for VfsListPrefer {
21477        type Error = self::error::ConversionError;
21478        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21479            value.parse()
21480        }
21481    }
21482
21483    impl ::std::convert::TryFrom<&::std::string::String> for VfsListPrefer {
21484        type Error = self::error::ConversionError;
21485        fn try_from(
21486            value: &::std::string::String,
21487        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21488            value.parse()
21489        }
21490    }
21491
21492    impl ::std::convert::TryFrom<::std::string::String> for VfsListPrefer {
21493        type Error = self::error::ConversionError;
21494        fn try_from(
21495            value: ::std::string::String,
21496        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21497            value.parse()
21498        }
21499    }
21500
21501    ///`VfsListRequest`
21502    ///
21503    /// <details><summary>JSON schema</summary>
21504    ///
21505    /// ```json
21506    ///{
21507    ///  "type": "object",
21508    ///  "properties": {
21509    ///    "_async": {
21510    ///      "description": "Run the command asynchronously. Returns a job id
21511    /// immediately.",
21512    ///      "type": "boolean"
21513    ///    },
21514    ///    "_group": {
21515    ///      "description": "Assign the request to a custom stats group.",
21516    ///      "type": "string"
21517    ///    },
21518    ///    "fs": {
21519    ///      "description": "Optional VFS identifier; omit to list all active
21520    /// VFS instances.",
21521    ///      "type": "string"
21522    ///    }
21523    ///  }
21524    ///}
21525    /// ```
21526    /// </details>
21527    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21528    pub struct VfsListRequest {
21529        ///Run the command asynchronously. Returns a job id immediately.
21530        #[serde(
21531            rename = "_async",
21532            default,
21533            skip_serializing_if = "::std::option::Option::is_none"
21534        )]
21535        pub async_: ::std::option::Option<bool>,
21536        ///Optional VFS identifier; omit to list all active VFS instances.
21537        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21538        pub fs: ::std::option::Option<::std::string::String>,
21539        ///Assign the request to a custom stats group.
21540        #[serde(
21541            rename = "_group",
21542            default,
21543            skip_serializing_if = "::std::option::Option::is_none"
21544        )]
21545        pub group: ::std::option::Option<::std::string::String>,
21546    }
21547
21548    impl ::std::convert::From<&VfsListRequest> for VfsListRequest {
21549        fn from(value: &VfsListRequest) -> Self {
21550            value.clone()
21551        }
21552    }
21553
21554    impl ::std::default::Default for VfsListRequest {
21555        fn default() -> Self {
21556            Self {
21557                async_: Default::default(),
21558                fs: Default::default(),
21559                group: Default::default(),
21560            }
21561        }
21562    }
21563
21564    ///`VfsListResponse`
21565    ///
21566    /// <details><summary>JSON schema</summary>
21567    ///
21568    /// ```json
21569    ///{
21570    ///  "type": "object",
21571    ///  "required": [
21572    ///    "vfses"
21573    ///  ],
21574    ///  "properties": {
21575    ///    "vfses": {
21576    ///      "description": "VFS name that can be used with other VFS
21577    /// endpoints.",
21578    ///      "type": "array",
21579    ///      "items": {
21580    ///        "type": "string"
21581    ///      }
21582    ///    }
21583    ///  }
21584    ///}
21585    /// ```
21586    /// </details>
21587    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21588    pub struct VfsListResponse {
21589        ///VFS name that can be used with other VFS endpoints.
21590        pub vfses: ::std::vec::Vec<::std::string::String>,
21591    }
21592
21593    impl ::std::convert::From<&VfsListResponse> for VfsListResponse {
21594        fn from(value: &VfsListResponse) -> Self {
21595            value.clone()
21596        }
21597    }
21598
21599    ///`VfsPollIntervalPrefer`
21600    ///
21601    /// <details><summary>JSON schema</summary>
21602    ///
21603    /// ```json
21604    ///{
21605    ///  "type": "string",
21606    ///  "enum": [
21607    ///    "respond-async"
21608    ///  ]
21609    ///}
21610    /// ```
21611    /// </details>
21612    #[derive(
21613        :: serde :: Deserialize,
21614        :: serde :: Serialize,
21615        Clone,
21616        Copy,
21617        Debug,
21618        Eq,
21619        Hash,
21620        Ord,
21621        PartialEq,
21622        PartialOrd,
21623    )]
21624    pub enum VfsPollIntervalPrefer {
21625        #[serde(rename = "respond-async")]
21626        RespondAsync,
21627    }
21628
21629    impl ::std::convert::From<&Self> for VfsPollIntervalPrefer {
21630        fn from(value: &VfsPollIntervalPrefer) -> Self {
21631            value.clone()
21632        }
21633    }
21634
21635    impl ::std::fmt::Display for VfsPollIntervalPrefer {
21636        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21637            match *self {
21638                Self::RespondAsync => f.write_str("respond-async"),
21639            }
21640        }
21641    }
21642
21643    impl ::std::str::FromStr for VfsPollIntervalPrefer {
21644        type Err = self::error::ConversionError;
21645        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21646            match value {
21647                "respond-async" => Ok(Self::RespondAsync),
21648                _ => Err("invalid value".into()),
21649            }
21650        }
21651    }
21652
21653    impl ::std::convert::TryFrom<&str> for VfsPollIntervalPrefer {
21654        type Error = self::error::ConversionError;
21655        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21656            value.parse()
21657        }
21658    }
21659
21660    impl ::std::convert::TryFrom<&::std::string::String> for VfsPollIntervalPrefer {
21661        type Error = self::error::ConversionError;
21662        fn try_from(
21663            value: &::std::string::String,
21664        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21665            value.parse()
21666        }
21667    }
21668
21669    impl ::std::convert::TryFrom<::std::string::String> for VfsPollIntervalPrefer {
21670        type Error = self::error::ConversionError;
21671        fn try_from(
21672            value: ::std::string::String,
21673        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21674            value.parse()
21675        }
21676    }
21677
21678    ///`VfsPollIntervalRequest`
21679    ///
21680    /// <details><summary>JSON schema</summary>
21681    ///
21682    /// ```json
21683    ///{
21684    ///  "type": "object",
21685    ///  "properties": {
21686    ///    "_async": {
21687    ///      "description": "Run the command asynchronously. Returns a job id
21688    /// immediately.",
21689    ///      "type": "boolean"
21690    ///    },
21691    ///    "_group": {
21692    ///      "description": "Assign the request to a custom stats group.",
21693    ///      "type": "string"
21694    ///    },
21695    ///    "fs": {
21696    ///      "description": "Optional VFS identifier whose poll interval should
21697    /// be queried or modified.",
21698    ///      "type": "string"
21699    ///    },
21700    ///    "interval": {
21701    ///      "description": "Duration string (e.g. `5m`) to set as the new poll
21702    /// interval.",
21703    ///      "type": "string"
21704    ///    },
21705    ///    "timeout": {
21706    ///      "description": "Duration to wait for the poll interval change to
21707    /// take effect; `0` waits indefinitely.",
21708    ///      "type": "string"
21709    ///    }
21710    ///  }
21711    ///}
21712    /// ```
21713    /// </details>
21714    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21715    pub struct VfsPollIntervalRequest {
21716        ///Run the command asynchronously. Returns a job id immediately.
21717        #[serde(
21718            rename = "_async",
21719            default,
21720            skip_serializing_if = "::std::option::Option::is_none"
21721        )]
21722        pub async_: ::std::option::Option<bool>,
21723        ///Optional VFS identifier whose poll interval should be queried or
21724        /// modified.
21725        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21726        pub fs: ::std::option::Option<::std::string::String>,
21727        ///Assign the request to a custom stats group.
21728        #[serde(
21729            rename = "_group",
21730            default,
21731            skip_serializing_if = "::std::option::Option::is_none"
21732        )]
21733        pub group: ::std::option::Option<::std::string::String>,
21734        ///Duration string (e.g. `5m`) to set as the new poll interval.
21735        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21736        pub interval: ::std::option::Option<::std::string::String>,
21737        ///Duration to wait for the poll interval change to take effect; `0`
21738        /// waits indefinitely.
21739        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21740        pub timeout: ::std::option::Option<::std::string::String>,
21741    }
21742
21743    impl ::std::convert::From<&VfsPollIntervalRequest> for VfsPollIntervalRequest {
21744        fn from(value: &VfsPollIntervalRequest) -> Self {
21745            value.clone()
21746        }
21747    }
21748
21749    impl ::std::default::Default for VfsPollIntervalRequest {
21750        fn default() -> Self {
21751            Self {
21752                async_: Default::default(),
21753                fs: Default::default(),
21754                group: Default::default(),
21755                interval: Default::default(),
21756                timeout: Default::default(),
21757            }
21758        }
21759    }
21760
21761    ///`VfsQueuePrefer`
21762    ///
21763    /// <details><summary>JSON schema</summary>
21764    ///
21765    /// ```json
21766    ///{
21767    ///  "type": "string",
21768    ///  "enum": [
21769    ///    "respond-async"
21770    ///  ]
21771    ///}
21772    /// ```
21773    /// </details>
21774    #[derive(
21775        :: serde :: Deserialize,
21776        :: serde :: Serialize,
21777        Clone,
21778        Copy,
21779        Debug,
21780        Eq,
21781        Hash,
21782        Ord,
21783        PartialEq,
21784        PartialOrd,
21785    )]
21786    pub enum VfsQueuePrefer {
21787        #[serde(rename = "respond-async")]
21788        RespondAsync,
21789    }
21790
21791    impl ::std::convert::From<&Self> for VfsQueuePrefer {
21792        fn from(value: &VfsQueuePrefer) -> Self {
21793            value.clone()
21794        }
21795    }
21796
21797    impl ::std::fmt::Display for VfsQueuePrefer {
21798        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21799            match *self {
21800                Self::RespondAsync => f.write_str("respond-async"),
21801            }
21802        }
21803    }
21804
21805    impl ::std::str::FromStr for VfsQueuePrefer {
21806        type Err = self::error::ConversionError;
21807        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21808            match value {
21809                "respond-async" => Ok(Self::RespondAsync),
21810                _ => Err("invalid value".into()),
21811            }
21812        }
21813    }
21814
21815    impl ::std::convert::TryFrom<&str> for VfsQueuePrefer {
21816        type Error = self::error::ConversionError;
21817        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21818            value.parse()
21819        }
21820    }
21821
21822    impl ::std::convert::TryFrom<&::std::string::String> for VfsQueuePrefer {
21823        type Error = self::error::ConversionError;
21824        fn try_from(
21825            value: &::std::string::String,
21826        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21827            value.parse()
21828        }
21829    }
21830
21831    impl ::std::convert::TryFrom<::std::string::String> for VfsQueuePrefer {
21832        type Error = self::error::ConversionError;
21833        fn try_from(
21834            value: ::std::string::String,
21835        ) -> ::std::result::Result<Self, self::error::ConversionError> {
21836            value.parse()
21837        }
21838    }
21839
21840    ///`VfsQueueRequest`
21841    ///
21842    /// <details><summary>JSON schema</summary>
21843    ///
21844    /// ```json
21845    ///{
21846    ///  "type": "object",
21847    ///  "properties": {
21848    ///    "_async": {
21849    ///      "description": "Run the command asynchronously. Returns a job id
21850    /// immediately.",
21851    ///      "type": "boolean"
21852    ///    },
21853    ///    "_group": {
21854    ///      "description": "Assign the request to a custom stats group.",
21855    ///      "type": "string"
21856    ///    },
21857    ///    "fs": {
21858    ///      "description": "Optional VFS identifier whose upload queue should
21859    /// be inspected.",
21860    ///      "type": "string"
21861    ///    }
21862    ///  }
21863    ///}
21864    /// ```
21865    /// </details>
21866    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21867    pub struct VfsQueueRequest {
21868        ///Run the command asynchronously. Returns a job id immediately.
21869        #[serde(
21870            rename = "_async",
21871            default,
21872            skip_serializing_if = "::std::option::Option::is_none"
21873        )]
21874        pub async_: ::std::option::Option<bool>,
21875        ///Optional VFS identifier whose upload queue should be inspected.
21876        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
21877        pub fs: ::std::option::Option<::std::string::String>,
21878        ///Assign the request to a custom stats group.
21879        #[serde(
21880            rename = "_group",
21881            default,
21882            skip_serializing_if = "::std::option::Option::is_none"
21883        )]
21884        pub group: ::std::option::Option<::std::string::String>,
21885    }
21886
21887    impl ::std::convert::From<&VfsQueueRequest> for VfsQueueRequest {
21888        fn from(value: &VfsQueueRequest) -> Self {
21889            value.clone()
21890        }
21891    }
21892
21893    impl ::std::default::Default for VfsQueueRequest {
21894        fn default() -> Self {
21895            Self {
21896                async_: Default::default(),
21897                fs: Default::default(),
21898                group: Default::default(),
21899            }
21900        }
21901    }
21902
21903    ///`VfsQueueResponse`
21904    ///
21905    /// <details><summary>JSON schema</summary>
21906    ///
21907    /// ```json
21908    ///{
21909    ///  "type": "object",
21910    ///  "properties": {
21911    ///    "queued": {
21912    ///      "type": "array",
21913    ///      "items": {
21914    ///        "description": "Queued item metadata such as name, size, expiry,
21915    /// and upload state.",
21916    ///        "type": "object",
21917    ///        "additionalProperties": true
21918    ///      }
21919    ///    }
21920    ///  }
21921    ///}
21922    /// ```
21923    /// </details>
21924    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
21925    pub struct VfsQueueResponse {
21926        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
21927        pub queued: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
21928    }
21929
21930    impl ::std::convert::From<&VfsQueueResponse> for VfsQueueResponse {
21931        fn from(value: &VfsQueueResponse) -> Self {
21932            value.clone()
21933        }
21934    }
21935
21936    impl ::std::default::Default for VfsQueueResponse {
21937        fn default() -> Self {
21938            Self {
21939                queued: Default::default(),
21940            }
21941        }
21942    }
21943
21944    ///`VfsQueueSetExpiryPrefer`
21945    ///
21946    /// <details><summary>JSON schema</summary>
21947    ///
21948    /// ```json
21949    ///{
21950    ///  "type": "string",
21951    ///  "enum": [
21952    ///    "respond-async"
21953    ///  ]
21954    ///}
21955    /// ```
21956    /// </details>
21957    #[derive(
21958        :: serde :: Deserialize,
21959        :: serde :: Serialize,
21960        Clone,
21961        Copy,
21962        Debug,
21963        Eq,
21964        Hash,
21965        Ord,
21966        PartialEq,
21967        PartialOrd,
21968    )]
21969    pub enum VfsQueueSetExpiryPrefer {
21970        #[serde(rename = "respond-async")]
21971        RespondAsync,
21972    }
21973
21974    impl ::std::convert::From<&Self> for VfsQueueSetExpiryPrefer {
21975        fn from(value: &VfsQueueSetExpiryPrefer) -> Self {
21976            value.clone()
21977        }
21978    }
21979
21980    impl ::std::fmt::Display for VfsQueueSetExpiryPrefer {
21981        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
21982            match *self {
21983                Self::RespondAsync => f.write_str("respond-async"),
21984            }
21985        }
21986    }
21987
21988    impl ::std::str::FromStr for VfsQueueSetExpiryPrefer {
21989        type Err = self::error::ConversionError;
21990        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
21991            match value {
21992                "respond-async" => Ok(Self::RespondAsync),
21993                _ => Err("invalid value".into()),
21994            }
21995        }
21996    }
21997
21998    impl ::std::convert::TryFrom<&str> for VfsQueueSetExpiryPrefer {
21999        type Error = self::error::ConversionError;
22000        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
22001            value.parse()
22002        }
22003    }
22004
22005    impl ::std::convert::TryFrom<&::std::string::String> for VfsQueueSetExpiryPrefer {
22006        type Error = self::error::ConversionError;
22007        fn try_from(
22008            value: &::std::string::String,
22009        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22010            value.parse()
22011        }
22012    }
22013
22014    impl ::std::convert::TryFrom<::std::string::String> for VfsQueueSetExpiryPrefer {
22015        type Error = self::error::ConversionError;
22016        fn try_from(
22017            value: ::std::string::String,
22018        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22019            value.parse()
22020        }
22021    }
22022
22023    ///`VfsQueueSetExpiryRequest`
22024    ///
22025    /// <details><summary>JSON schema</summary>
22026    ///
22027    /// ```json
22028    ///{
22029    ///  "type": "object",
22030    ///  "properties": {
22031    ///    "_async": {
22032    ///      "description": "Run the command asynchronously. Returns a job id
22033    /// immediately.",
22034    ///      "type": "boolean"
22035    ///    },
22036    ///    "_group": {
22037    ///      "description": "Assign the request to a custom stats group.",
22038    ///      "type": "string"
22039    ///    },
22040    ///    "expiry": {
22041    ///      "description": "New eligibility time in seconds (may be negative
22042    /// for immediate upload).",
22043    ///      "type": "number"
22044    ///    },
22045    ///    "fs": {
22046    ///      "description": "Optional VFS identifier for the queued item.",
22047    ///      "type": "string"
22048    ///    },
22049    ///    "id": {
22050    ///      "description": "Queue item ID as returned by `vfs/queue`.",
22051    ///      "type": "integer"
22052    ///    },
22053    ///    "relative": {
22054    ///      "description": "Set to true to treat `expiry` as relative to the
22055    /// current value.",
22056    ///      "type": "boolean"
22057    ///    }
22058    ///  }
22059    ///}
22060    /// ```
22061    /// </details>
22062    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
22063    pub struct VfsQueueSetExpiryRequest {
22064        ///Run the command asynchronously. Returns a job id immediately.
22065        #[serde(
22066            rename = "_async",
22067            default,
22068            skip_serializing_if = "::std::option::Option::is_none"
22069        )]
22070        pub async_: ::std::option::Option<bool>,
22071        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22072        pub expiry: ::std::option::Option<f64>,
22073        ///Optional VFS identifier for the queued item.
22074        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22075        pub fs: ::std::option::Option<::std::string::String>,
22076        ///Assign the request to a custom stats group.
22077        #[serde(
22078            rename = "_group",
22079            default,
22080            skip_serializing_if = "::std::option::Option::is_none"
22081        )]
22082        pub group: ::std::option::Option<::std::string::String>,
22083        ///Queue item ID as returned by `vfs/queue`.
22084        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22085        pub id: ::std::option::Option<i64>,
22086        ///Set to true to treat `expiry` as relative to the current value.
22087        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22088        pub relative: ::std::option::Option<bool>,
22089    }
22090
22091    impl ::std::convert::From<&VfsQueueSetExpiryRequest> for VfsQueueSetExpiryRequest {
22092        fn from(value: &VfsQueueSetExpiryRequest) -> Self {
22093            value.clone()
22094        }
22095    }
22096
22097    impl ::std::default::Default for VfsQueueSetExpiryRequest {
22098        fn default() -> Self {
22099            Self {
22100                async_: Default::default(),
22101                expiry: Default::default(),
22102                fs: Default::default(),
22103                group: Default::default(),
22104                id: Default::default(),
22105                relative: Default::default(),
22106            }
22107        }
22108    }
22109
22110    ///`VfsRefreshPrefer`
22111    ///
22112    /// <details><summary>JSON schema</summary>
22113    ///
22114    /// ```json
22115    ///{
22116    ///  "type": "string",
22117    ///  "enum": [
22118    ///    "respond-async"
22119    ///  ]
22120    ///}
22121    /// ```
22122    /// </details>
22123    #[derive(
22124        :: serde :: Deserialize,
22125        :: serde :: Serialize,
22126        Clone,
22127        Copy,
22128        Debug,
22129        Eq,
22130        Hash,
22131        Ord,
22132        PartialEq,
22133        PartialOrd,
22134    )]
22135    pub enum VfsRefreshPrefer {
22136        #[serde(rename = "respond-async")]
22137        RespondAsync,
22138    }
22139
22140    impl ::std::convert::From<&Self> for VfsRefreshPrefer {
22141        fn from(value: &VfsRefreshPrefer) -> Self {
22142            value.clone()
22143        }
22144    }
22145
22146    impl ::std::fmt::Display for VfsRefreshPrefer {
22147        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
22148            match *self {
22149                Self::RespondAsync => f.write_str("respond-async"),
22150            }
22151        }
22152    }
22153
22154    impl ::std::str::FromStr for VfsRefreshPrefer {
22155        type Err = self::error::ConversionError;
22156        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
22157            match value {
22158                "respond-async" => Ok(Self::RespondAsync),
22159                _ => Err("invalid value".into()),
22160            }
22161        }
22162    }
22163
22164    impl ::std::convert::TryFrom<&str> for VfsRefreshPrefer {
22165        type Error = self::error::ConversionError;
22166        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
22167            value.parse()
22168        }
22169    }
22170
22171    impl ::std::convert::TryFrom<&::std::string::String> for VfsRefreshPrefer {
22172        type Error = self::error::ConversionError;
22173        fn try_from(
22174            value: &::std::string::String,
22175        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22176            value.parse()
22177        }
22178    }
22179
22180    impl ::std::convert::TryFrom<::std::string::String> for VfsRefreshPrefer {
22181        type Error = self::error::ConversionError;
22182        fn try_from(
22183            value: ::std::string::String,
22184        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22185            value.parse()
22186        }
22187    }
22188
22189    ///`VfsRefreshRequest`
22190    ///
22191    /// <details><summary>JSON schema</summary>
22192    ///
22193    /// ```json
22194    ///{
22195    ///  "type": "object",
22196    ///  "properties": {
22197    ///    "_async": {
22198    ///      "description": "Run the command asynchronously. Returns a job id
22199    /// immediately.",
22200    ///      "type": "boolean"
22201    ///    },
22202    ///    "_group": {
22203    ///      "description": "Assign the request to a custom stats group.",
22204    ///      "type": "string"
22205    ///    },
22206    ///    "fs": {
22207    ///      "description": "Optional VFS identifier whose directory cache
22208    /// should be refreshed.",
22209    ///      "type": "string"
22210    ///    },
22211    ///    "recursive": {
22212    ///      "description": "Set to true to refresh entire directory trees.",
22213    ///      "type": "boolean"
22214    ///    }
22215    ///  },
22216    ///  "additionalProperties": true
22217    ///}
22218    /// ```
22219    /// </details>
22220    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
22221    pub struct VfsRefreshRequest {
22222        ///Run the command asynchronously. Returns a job id immediately.
22223        #[serde(
22224            rename = "_async",
22225            default,
22226            skip_serializing_if = "::std::option::Option::is_none"
22227        )]
22228        pub async_: ::std::option::Option<bool>,
22229        ///Optional VFS identifier whose directory cache should be refreshed.
22230        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22231        pub fs: ::std::option::Option<::std::string::String>,
22232        ///Assign the request to a custom stats group.
22233        #[serde(
22234            rename = "_group",
22235            default,
22236            skip_serializing_if = "::std::option::Option::is_none"
22237        )]
22238        pub group: ::std::option::Option<::std::string::String>,
22239        ///Set to true to refresh entire directory trees.
22240        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22241        pub recursive: ::std::option::Option<bool>,
22242    }
22243
22244    impl ::std::convert::From<&VfsRefreshRequest> for VfsRefreshRequest {
22245        fn from(value: &VfsRefreshRequest) -> Self {
22246            value.clone()
22247        }
22248    }
22249
22250    impl ::std::default::Default for VfsRefreshRequest {
22251        fn default() -> Self {
22252            Self {
22253                async_: Default::default(),
22254                fs: Default::default(),
22255                group: Default::default(),
22256                recursive: Default::default(),
22257            }
22258        }
22259    }
22260
22261    ///`VfsRefreshResponse`
22262    ///
22263    /// <details><summary>JSON schema</summary>
22264    ///
22265    /// ```json
22266    ///{
22267    ///  "type": "object",
22268    ///  "required": [
22269    ///    "result"
22270    ///  ],
22271    ///  "properties": {
22272    ///    "result": {
22273    ///      "description": "Map of refreshed directories to status messages.",
22274    ///      "type": "object",
22275    ///      "additionalProperties": {
22276    ///        "type": "string"
22277    ///      }
22278    ///    }
22279    ///  }
22280    ///}
22281    /// ```
22282    /// </details>
22283    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
22284    pub struct VfsRefreshResponse {
22285        ///Map of refreshed directories to status messages.
22286        pub result: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
22287    }
22288
22289    impl ::std::convert::From<&VfsRefreshResponse> for VfsRefreshResponse {
22290        fn from(value: &VfsRefreshResponse) -> Self {
22291            value.clone()
22292        }
22293    }
22294
22295    ///`VfsStatsPrefer`
22296    ///
22297    /// <details><summary>JSON schema</summary>
22298    ///
22299    /// ```json
22300    ///{
22301    ///  "type": "string",
22302    ///  "enum": [
22303    ///    "respond-async"
22304    ///  ]
22305    ///}
22306    /// ```
22307    /// </details>
22308    #[derive(
22309        :: serde :: Deserialize,
22310        :: serde :: Serialize,
22311        Clone,
22312        Copy,
22313        Debug,
22314        Eq,
22315        Hash,
22316        Ord,
22317        PartialEq,
22318        PartialOrd,
22319    )]
22320    pub enum VfsStatsPrefer {
22321        #[serde(rename = "respond-async")]
22322        RespondAsync,
22323    }
22324
22325    impl ::std::convert::From<&Self> for VfsStatsPrefer {
22326        fn from(value: &VfsStatsPrefer) -> Self {
22327            value.clone()
22328        }
22329    }
22330
22331    impl ::std::fmt::Display for VfsStatsPrefer {
22332        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
22333            match *self {
22334                Self::RespondAsync => f.write_str("respond-async"),
22335            }
22336        }
22337    }
22338
22339    impl ::std::str::FromStr for VfsStatsPrefer {
22340        type Err = self::error::ConversionError;
22341        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
22342            match value {
22343                "respond-async" => Ok(Self::RespondAsync),
22344                _ => Err("invalid value".into()),
22345            }
22346        }
22347    }
22348
22349    impl ::std::convert::TryFrom<&str> for VfsStatsPrefer {
22350        type Error = self::error::ConversionError;
22351        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
22352            value.parse()
22353        }
22354    }
22355
22356    impl ::std::convert::TryFrom<&::std::string::String> for VfsStatsPrefer {
22357        type Error = self::error::ConversionError;
22358        fn try_from(
22359            value: &::std::string::String,
22360        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22361            value.parse()
22362        }
22363    }
22364
22365    impl ::std::convert::TryFrom<::std::string::String> for VfsStatsPrefer {
22366        type Error = self::error::ConversionError;
22367        fn try_from(
22368            value: ::std::string::String,
22369        ) -> ::std::result::Result<Self, self::error::ConversionError> {
22370            value.parse()
22371        }
22372    }
22373
22374    ///`VfsStatsRequest`
22375    ///
22376    /// <details><summary>JSON schema</summary>
22377    ///
22378    /// ```json
22379    ///{
22380    ///  "type": "object",
22381    ///  "properties": {
22382    ///    "_async": {
22383    ///      "description": "Run the command asynchronously. Returns a job id
22384    /// immediately.",
22385    ///      "type": "boolean"
22386    ///    },
22387    ///    "_group": {
22388    ///      "description": "Assign the request to a custom stats group.",
22389    ///      "type": "string"
22390    ///    },
22391    ///    "fs": {
22392    ///      "description": "Optional VFS identifier whose statistics should be
22393    /// returned.",
22394    ///      "type": "string"
22395    ///    }
22396    ///  }
22397    ///}
22398    /// ```
22399    /// </details>
22400    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
22401    pub struct VfsStatsRequest {
22402        ///Run the command asynchronously. Returns a job id immediately.
22403        #[serde(
22404            rename = "_async",
22405            default,
22406            skip_serializing_if = "::std::option::Option::is_none"
22407        )]
22408        pub async_: ::std::option::Option<bool>,
22409        ///Optional VFS identifier whose statistics should be returned.
22410        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
22411        pub fs: ::std::option::Option<::std::string::String>,
22412        ///Assign the request to a custom stats group.
22413        #[serde(
22414            rename = "_group",
22415            default,
22416            skip_serializing_if = "::std::option::Option::is_none"
22417        )]
22418        pub group: ::std::option::Option<::std::string::String>,
22419    }
22420
22421    impl ::std::convert::From<&VfsStatsRequest> for VfsStatsRequest {
22422        fn from(value: &VfsStatsRequest) -> Self {
22423            value.clone()
22424        }
22425    }
22426
22427    impl ::std::default::Default for VfsStatsRequest {
22428        fn default() -> Self {
22429            Self {
22430                async_: Default::default(),
22431                fs: Default::default(),
22432                group: Default::default(),
22433            }
22434        }
22435    }
22436
22437    ///`VfsStatsResponse`
22438    ///
22439    /// <details><summary>JSON schema</summary>
22440    ///
22441    /// ```json
22442    ///{
22443    ///  "type": "object",
22444    ///  "required": [
22445    ///    "fs",
22446    ///    "inUse",
22447    ///    "metadataCache",
22448    ///    "opt"
22449    ///  ],
22450    ///  "properties": {
22451    ///    "diskCache": {
22452    ///      "description": "Disk cache metrics when caching is enabled.",
22453    ///      "type": [
22454    ///        "object",
22455    ///        "null"
22456    ///      ],
22457    ///      "additionalProperties": true
22458    ///    },
22459    ///    "fs": {
22460    ///      "description": "Name of the VFS.",
22461    ///      "type": "string"
22462    ///    },
22463    ///    "inUse": {
22464    ///      "description": "Number of active references to the VFS.",
22465    ///      "type": "integer"
22466    ///    },
22467    ///    "metadataCache": {
22468    ///      "description": "In-memory metadata cache counters.",
22469    ///      "type": "object",
22470    ///      "additionalProperties": {
22471    ///        "type": "integer"
22472    ///      }
22473    ///    },
22474    ///    "opt": {
22475    ///      "description": "Effective options applied to the VFS.",
22476    ///      "type": "object",
22477    ///      "additionalProperties": true
22478    ///    }
22479    ///  }
22480    ///}
22481    /// ```
22482    /// </details>
22483    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
22484    pub struct VfsStatsResponse {
22485        ///Disk cache metrics when caching is enabled.
22486        #[serde(
22487            rename = "diskCache",
22488            default,
22489            skip_serializing_if = "::std::option::Option::is_none"
22490        )]
22491        pub disk_cache:
22492            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22493        ///Name of the VFS.
22494        pub fs: ::std::string::String,
22495        ///Number of active references to the VFS.
22496        #[serde(rename = "inUse")]
22497        pub in_use: i64,
22498        ///In-memory metadata cache counters.
22499        #[serde(rename = "metadataCache")]
22500        pub metadata_cache: ::std::collections::HashMap<::std::string::String, i64>,
22501        ///Effective options applied to the VFS.
22502        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
22503    }
22504
22505    impl ::std::convert::From<&VfsStatsResponse> for VfsStatsResponse {
22506        fn from(value: &VfsStatsResponse) -> Self {
22507            value.clone()
22508        }
22509    }
22510}
22511
22512#[derive(Clone, Debug)]
22513///Client for Rclone RC API
22514///
22515///Full OpenAPI specification for the Rclone RC API.
22516///
22517///Version: 1.75.0
22518pub struct Client {
22519    pub(crate) baseurl: String,
22520    pub(crate) client: reqwest::Client,
22521}
22522
22523impl Client {
22524    /// Create a new client.
22525    ///
22526    /// `baseurl` is the base URL provided to the internal
22527    /// `reqwest::Client`, and should include a scheme and hostname,
22528    /// as well as port and a path stem if applicable.
22529    pub fn new(baseurl: &str) -> Self {
22530        #[cfg(not(target_arch = "wasm32"))]
22531        let client = {
22532            let dur = ::std::time::Duration::from_secs(15u64);
22533            reqwest::ClientBuilder::new()
22534                .connect_timeout(dur)
22535                .timeout(dur)
22536        };
22537        #[cfg(target_arch = "wasm32")]
22538        let client = reqwest::ClientBuilder::new();
22539        Self::new_with_client(baseurl, client.build().unwrap())
22540    }
22541
22542    /// Construct a new client with an existing `reqwest::Client`,
22543    /// allowing more control over its configuration.
22544    ///
22545    /// `baseurl` is the base URL provided to the internal
22546    /// `reqwest::Client`, and should include a scheme and hostname,
22547    /// as well as port and a path stem if applicable.
22548    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
22549        Self {
22550            baseurl: baseurl.to_string(),
22551            client,
22552        }
22553    }
22554}
22555
22556impl ClientInfo<()> for Client {
22557    fn api_version() -> &'static str {
22558        "1.75.0"
22559    }
22560
22561    fn baseurl(&self) -> &str {
22562        self.baseurl.as_str()
22563    }
22564
22565    fn client(&self) -> &reqwest::Client {
22566        &self.client
22567    }
22568
22569    fn inner(&self) -> &() {
22570        &()
22571    }
22572}
22573
22574impl ClientHooks<()> for &Client {}
22575#[allow(clippy::all)]
22576impl Client {
22577    ///Echo request parameters
22578    ///
22579    ///Returns all supplied parameters unchanged so you can verify RC
22580    /// connectivity.
22581    ///
22582    ///Sends a `POST` request to `/rc/noop`
22583    ///
22584    ///Arguments:
22585    /// - `async_`: Run the command asynchronously. Returns a job id
22586    ///   immediately.
22587    /// - `params`: Additional arbitrary parameters allowed.
22588    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22589    ///   instead of 200.
22590    /// - `body`
22591    pub async fn rc_noop<'a>(
22592        &'a self,
22593        async_: Option<bool>,
22594        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22595        prefer: Option<types::RcNoopPrefer>,
22596        body: &'a types::RcNoopRequest,
22597    ) -> Result<
22598        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22599        Error<types::RcError>,
22600    > {
22601        let url = format!("{}/rc/noop", self.baseurl,);
22602        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22603        header_map.append(
22604            ::reqwest::header::HeaderName::from_static("api-version"),
22605            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22606        );
22607        if let Some(value) = prefer {
22608            header_map.append("Prefer", value.to_string().try_into()?);
22609        }
22610
22611        #[allow(unused_mut)]
22612        let mut request = self
22613            .client
22614            .post(url)
22615            .header(
22616                ::reqwest::header::ACCEPT,
22617                ::reqwest::header::HeaderValue::from_static("application/json"),
22618            )
22619            .json(&body)
22620            .query(&progenitor_client::QueryParam::new("_async", &async_))
22621            .query(&progenitor_client::QueryParam::new("params", &params))
22622            .headers(header_map)
22623            .build()?;
22624        let info = OperationInfo {
22625            operation_id: "rc_noop",
22626        };
22627        self.pre(&mut request, &info).await?;
22628        let result = self.exec(request, &info).await;
22629        self.post(&result, &info).await?;
22630        let response = result?;
22631        match response.status().as_u16() {
22632            200u16 => ResponseValue::from_response(response).await,
22633            400u16..=499u16 => Err(Error::ErrorResponse(
22634                ResponseValue::from_response(response).await?,
22635            )),
22636            500u16..=599u16 => Err(Error::ErrorResponse(
22637                ResponseValue::from_response(response).await?,
22638            )),
22639            _ => Err(Error::UnexpectedResponse(response)),
22640        }
22641    }
22642
22643    ///Remove trashed files
22644    ///
22645    ///Permanently removes trashed objects from the specified remote path.
22646    ///
22647    ///Sends a `POST` request to `/operations/cleanup`
22648    ///
22649    ///Arguments:
22650    /// - `async_`: Run the command asynchronously. Returns a job id
22651    ///   immediately.
22652    /// - `group`: Assign the request to a custom stats group.
22653    /// - `fs`: Remote name or path to clean up, for example `drive:`.
22654    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22655    ///   instead of 200.
22656    /// - `body`
22657    pub async fn operations_cleanup<'a>(
22658        &'a self,
22659        async_: Option<bool>,
22660        group: Option<&'a str>,
22661        fs: Option<&'a str>,
22662        prefer: Option<types::OperationsCleanupPrefer>,
22663        body: &'a types::OperationsCleanupRequest,
22664    ) -> Result<
22665        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22666        Error<types::RcError>,
22667    > {
22668        let url = format!("{}/operations/cleanup", self.baseurl,);
22669        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22670        header_map.append(
22671            ::reqwest::header::HeaderName::from_static("api-version"),
22672            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22673        );
22674        if let Some(value) = prefer {
22675            header_map.append("Prefer", value.to_string().try_into()?);
22676        }
22677
22678        #[allow(unused_mut)]
22679        let mut request = self
22680            .client
22681            .post(url)
22682            .header(
22683                ::reqwest::header::ACCEPT,
22684                ::reqwest::header::HeaderValue::from_static("application/json"),
22685            )
22686            .json(&body)
22687            .query(&progenitor_client::QueryParam::new("_async", &async_))
22688            .query(&progenitor_client::QueryParam::new("_group", &group))
22689            .query(&progenitor_client::QueryParam::new("fs", &fs))
22690            .headers(header_map)
22691            .build()?;
22692        let info = OperationInfo {
22693            operation_id: "operations_cleanup",
22694        };
22695        self.pre(&mut request, &info).await?;
22696        let result = self.exec(request, &info).await;
22697        self.post(&result, &info).await?;
22698        let response = result?;
22699        match response.status().as_u16() {
22700            200u16 => ResponseValue::from_response(response).await,
22701            400u16..=499u16 => Err(Error::ErrorResponse(
22702                ResponseValue::from_response(response).await?,
22703            )),
22704            500u16..=599u16 => Err(Error::ErrorResponse(
22705                ResponseValue::from_response(response).await?,
22706            )),
22707            _ => Err(Error::UnexpectedResponse(response)),
22708        }
22709    }
22710
22711    ///Copy a single file
22712    ///
22713    ///Copies one object from a source remote and path to a destination remote
22714    /// and path.
22715    ///
22716    ///Sends a `POST` request to `/operations/copyfile`
22717    ///
22718    ///Arguments:
22719    /// - `async_`: Run the command asynchronously. Returns a job id
22720    ///   immediately.
22721    /// - `group`: Assign the request to a custom stats group.
22722    /// - `dst_fs`: Destination remote name or path, such as `drive2:` or `/`
22723    ///   for local filesystem.
22724    /// - `dst_remote`: Target path within `dstFs` where the file should be
22725    ///   written.
22726    /// - `src_fs`: Source remote name or path, such as `drive:` or `/` for the
22727    ///   local filesystem.
22728    /// - `src_remote`: Path to the source object within `srcFs`, for example
22729    ///   `dir/file.txt`.
22730    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22731    ///   instead of 200.
22732    /// - `body`
22733    pub async fn operations_copyfile<'a>(
22734        &'a self,
22735        async_: Option<bool>,
22736        group: Option<&'a str>,
22737        dst_fs: Option<&'a str>,
22738        dst_remote: Option<&'a str>,
22739        src_fs: Option<&'a str>,
22740        src_remote: Option<&'a str>,
22741        prefer: Option<types::OperationsCopyfilePrefer>,
22742        body: &'a types::OperationsCopyfileRequest,
22743    ) -> Result<
22744        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22745        Error<types::RcError>,
22746    > {
22747        let url = format!("{}/operations/copyfile", self.baseurl,);
22748        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22749        header_map.append(
22750            ::reqwest::header::HeaderName::from_static("api-version"),
22751            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22752        );
22753        if let Some(value) = prefer {
22754            header_map.append("Prefer", value.to_string().try_into()?);
22755        }
22756
22757        #[allow(unused_mut)]
22758        let mut request = self
22759            .client
22760            .post(url)
22761            .header(
22762                ::reqwest::header::ACCEPT,
22763                ::reqwest::header::HeaderValue::from_static("application/json"),
22764            )
22765            .json(&body)
22766            .query(&progenitor_client::QueryParam::new("_async", &async_))
22767            .query(&progenitor_client::QueryParam::new("_group", &group))
22768            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
22769            .query(&progenitor_client::QueryParam::new(
22770                "dstRemote",
22771                &dst_remote,
22772            ))
22773            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
22774            .query(&progenitor_client::QueryParam::new(
22775                "srcRemote",
22776                &src_remote,
22777            ))
22778            .headers(header_map)
22779            .build()?;
22780        let info = OperationInfo {
22781            operation_id: "operations_copyfile",
22782        };
22783        self.pre(&mut request, &info).await?;
22784        let result = self.exec(request, &info).await;
22785        self.post(&result, &info).await?;
22786        let response = result?;
22787        match response.status().as_u16() {
22788            200u16 => ResponseValue::from_response(response).await,
22789            400u16..=499u16 => Err(Error::ErrorResponse(
22790                ResponseValue::from_response(response).await?,
22791            )),
22792            500u16..=599u16 => Err(Error::ErrorResponse(
22793                ResponseValue::from_response(response).await?,
22794            )),
22795            _ => Err(Error::UnexpectedResponse(response)),
22796        }
22797    }
22798
22799    ///Copy from URL
22800    ///
22801    ///Downloads a public URL and stores it at the requested remote path.
22802    ///
22803    ///Sends a `POST` request to `/operations/copyurl`
22804    ///
22805    ///Arguments:
22806    /// - `async_`: Run the command asynchronously. Returns a job id
22807    ///   immediately.
22808    /// - `group`: Assign the request to a custom stats group.
22809    /// - `auto_filename`: Set to true to derive the destination filename from
22810    ///   the URL.
22811    /// - `fs`: Remote name or path that will receive the downloaded file, e.g.
22812    ///   `drive:`.
22813    /// - `remote`: Destination path within `fs` where the fetched object will
22814    ///   be stored.
22815    /// - `url`: Source URL to fetch the object from.
22816    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22817    ///   instead of 200.
22818    /// - `body`
22819    pub async fn operations_copyurl<'a>(
22820        &'a self,
22821        async_: Option<bool>,
22822        group: Option<&'a str>,
22823        auto_filename: Option<bool>,
22824        fs: Option<&'a str>,
22825        remote: Option<&'a str>,
22826        url: Option<&'a str>,
22827        prefer: Option<types::OperationsCopyurlPrefer>,
22828        body: &'a types::OperationsCopyurlRequest,
22829    ) -> Result<
22830        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22831        Error<types::RcError>,
22832    > {
22833        let _url = format!("{}/operations/copyurl", self.baseurl,);
22834        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22835        header_map.append(
22836            ::reqwest::header::HeaderName::from_static("api-version"),
22837            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22838        );
22839        if let Some(value) = prefer {
22840            header_map.append("Prefer", value.to_string().try_into()?);
22841        }
22842
22843        #[allow(unused_mut)]
22844        let mut request = self
22845            .client
22846            .post(_url)
22847            .header(
22848                ::reqwest::header::ACCEPT,
22849                ::reqwest::header::HeaderValue::from_static("application/json"),
22850            )
22851            .json(&body)
22852            .query(&progenitor_client::QueryParam::new("_async", &async_))
22853            .query(&progenitor_client::QueryParam::new("_group", &group))
22854            .query(&progenitor_client::QueryParam::new(
22855                "autoFilename",
22856                &auto_filename,
22857            ))
22858            .query(&progenitor_client::QueryParam::new("fs", &fs))
22859            .query(&progenitor_client::QueryParam::new("remote", &remote))
22860            .query(&progenitor_client::QueryParam::new("url", &url))
22861            .headers(header_map)
22862            .build()?;
22863        let info = OperationInfo {
22864            operation_id: "operations_copyurl",
22865        };
22866        self.pre(&mut request, &info).await?;
22867        let result = self.exec(request, &info).await;
22868        self.post(&result, &info).await?;
22869        let response = result?;
22870        match response.status().as_u16() {
22871            200u16 => ResponseValue::from_response(response).await,
22872            400u16..=499u16 => Err(Error::ErrorResponse(
22873                ResponseValue::from_response(response).await?,
22874            )),
22875            500u16..=599u16 => Err(Error::ErrorResponse(
22876                ResponseValue::from_response(response).await?,
22877            )),
22878            _ => Err(Error::UnexpectedResponse(response)),
22879        }
22880    }
22881
22882    ///Delete objects in path
22883    ///
22884    ///Deletes matching files and directories for the provided remote,
22885    /// honouring filters and config overrides.
22886    ///
22887    ///Sends a `POST` request to `/operations/delete`
22888    ///
22889    ///Arguments:
22890    /// - `async_`: Run the command asynchronously. Returns a job id
22891    ///   immediately.
22892    /// - `config`: JSON encoded config overrides applied for this call only.
22893    /// - `filter`: JSON encoded filter overrides applied for this call only.
22894    /// - `group`: Assign the request to a custom stats group.
22895    /// - `fs`: Remote name or path whose contents should be removed.
22896    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22897    ///   instead of 200.
22898    /// - `body`
22899    pub async fn operations_delete<'a>(
22900        &'a self,
22901        async_: Option<bool>,
22902        config: Option<&'a str>,
22903        filter: Option<&'a str>,
22904        group: Option<&'a str>,
22905        fs: Option<&'a str>,
22906        prefer: Option<types::OperationsDeletePrefer>,
22907        body: &'a types::OperationsDeleteRequest,
22908    ) -> Result<
22909        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22910        Error<types::RcError>,
22911    > {
22912        let url = format!("{}/operations/delete", self.baseurl,);
22913        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22914        header_map.append(
22915            ::reqwest::header::HeaderName::from_static("api-version"),
22916            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22917        );
22918        if let Some(value) = prefer {
22919            header_map.append("Prefer", value.to_string().try_into()?);
22920        }
22921
22922        #[allow(unused_mut)]
22923        let mut request = self
22924            .client
22925            .post(url)
22926            .header(
22927                ::reqwest::header::ACCEPT,
22928                ::reqwest::header::HeaderValue::from_static("application/json"),
22929            )
22930            .json(&body)
22931            .query(&progenitor_client::QueryParam::new("_async", &async_))
22932            .query(&progenitor_client::QueryParam::new("_config", &config))
22933            .query(&progenitor_client::QueryParam::new("_filter", &filter))
22934            .query(&progenitor_client::QueryParam::new("_group", &group))
22935            .query(&progenitor_client::QueryParam::new("fs", &fs))
22936            .headers(header_map)
22937            .build()?;
22938        let info = OperationInfo {
22939            operation_id: "operations_delete",
22940        };
22941        self.pre(&mut request, &info).await?;
22942        let result = self.exec(request, &info).await;
22943        self.post(&result, &info).await?;
22944        let response = result?;
22945        match response.status().as_u16() {
22946            200u16 => ResponseValue::from_response(response).await,
22947            400u16..=499u16 => Err(Error::ErrorResponse(
22948                ResponseValue::from_response(response).await?,
22949            )),
22950            500u16..=599u16 => Err(Error::ErrorResponse(
22951                ResponseValue::from_response(response).await?,
22952            )),
22953            _ => Err(Error::UnexpectedResponse(response)),
22954        }
22955    }
22956
22957    ///Delete single file
22958    ///
22959    ///Removes a specific object from the remote.
22960    ///
22961    ///Sends a `POST` request to `/operations/deletefile`
22962    ///
22963    ///Arguments:
22964    /// - `async_`: Run the command asynchronously. Returns a job id
22965    ///   immediately.
22966    /// - `group`: Assign the request to a custom stats group.
22967    /// - `fs`: Remote name or path that contains the file to delete.
22968    /// - `remote`: Exact path to the file within `fs` that should be deleted.
22969    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
22970    ///   instead of 200.
22971    /// - `body`
22972    pub async fn operations_deletefile<'a>(
22973        &'a self,
22974        async_: Option<bool>,
22975        group: Option<&'a str>,
22976        fs: Option<&'a str>,
22977        remote: Option<&'a str>,
22978        prefer: Option<types::OperationsDeletefilePrefer>,
22979        body: &'a types::OperationsDeletefileRequest,
22980    ) -> Result<
22981        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
22982        Error<types::RcError>,
22983    > {
22984        let url = format!("{}/operations/deletefile", self.baseurl,);
22985        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
22986        header_map.append(
22987            ::reqwest::header::HeaderName::from_static("api-version"),
22988            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
22989        );
22990        if let Some(value) = prefer {
22991            header_map.append("Prefer", value.to_string().try_into()?);
22992        }
22993
22994        #[allow(unused_mut)]
22995        let mut request = self
22996            .client
22997            .post(url)
22998            .header(
22999                ::reqwest::header::ACCEPT,
23000                ::reqwest::header::HeaderValue::from_static("application/json"),
23001            )
23002            .json(&body)
23003            .query(&progenitor_client::QueryParam::new("_async", &async_))
23004            .query(&progenitor_client::QueryParam::new("_group", &group))
23005            .query(&progenitor_client::QueryParam::new("fs", &fs))
23006            .query(&progenitor_client::QueryParam::new("remote", &remote))
23007            .headers(header_map)
23008            .build()?;
23009        let info = OperationInfo {
23010            operation_id: "operations_deletefile",
23011        };
23012        self.pre(&mut request, &info).await?;
23013        let result = self.exec(request, &info).await;
23014        self.post(&result, &info).await?;
23015        let response = result?;
23016        match response.status().as_u16() {
23017            200u16 => ResponseValue::from_response(response).await,
23018            400u16..=499u16 => Err(Error::ErrorResponse(
23019                ResponseValue::from_response(response).await?,
23020            )),
23021            500u16..=599u16 => Err(Error::ErrorResponse(
23022                ResponseValue::from_response(response).await?,
23023            )),
23024            _ => Err(Error::UnexpectedResponse(response)),
23025        }
23026    }
23027
23028    ///Describe remote capabilities
23029    ///
23030    ///Returns backend features, hash support, metadata descriptions, and other
23031    /// info for the remote.
23032    ///
23033    ///Sends a `POST` request to `/operations/fsinfo`
23034    ///
23035    ///Arguments:
23036    /// - `async_`: Run the command asynchronously. Returns a job id
23037    ///   immediately.
23038    /// - `group`: Assign the request to a custom stats group.
23039    /// - `fs`: Remote name or path to inspect, e.g. `drive:`.
23040    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23041    ///   instead of 200.
23042    /// - `body`
23043    pub async fn operations_fsinfo<'a>(
23044        &'a self,
23045        async_: Option<bool>,
23046        group: Option<&'a str>,
23047        fs: Option<&'a str>,
23048        prefer: Option<types::OperationsFsinfoPrefer>,
23049        body: &'a types::OperationsFsinfoRequest,
23050    ) -> Result<ResponseValue<types::OperationsFsinfoResponse>, Error<types::RcError>> {
23051        let url = format!("{}/operations/fsinfo", self.baseurl,);
23052        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23053        header_map.append(
23054            ::reqwest::header::HeaderName::from_static("api-version"),
23055            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23056        );
23057        if let Some(value) = prefer {
23058            header_map.append("Prefer", value.to_string().try_into()?);
23059        }
23060
23061        #[allow(unused_mut)]
23062        let mut request = self
23063            .client
23064            .post(url)
23065            .header(
23066                ::reqwest::header::ACCEPT,
23067                ::reqwest::header::HeaderValue::from_static("application/json"),
23068            )
23069            .json(&body)
23070            .query(&progenitor_client::QueryParam::new("_async", &async_))
23071            .query(&progenitor_client::QueryParam::new("_group", &group))
23072            .query(&progenitor_client::QueryParam::new("fs", &fs))
23073            .headers(header_map)
23074            .build()?;
23075        let info = OperationInfo {
23076            operation_id: "operations_fsinfo",
23077        };
23078        self.pre(&mut request, &info).await?;
23079        let result = self.exec(request, &info).await;
23080        self.post(&result, &info).await?;
23081        let response = result?;
23082        match response.status().as_u16() {
23083            200u16 => ResponseValue::from_response(response).await,
23084            400u16..=499u16 => Err(Error::ErrorResponse(
23085                ResponseValue::from_response(response).await?,
23086            )),
23087            500u16..=599u16 => Err(Error::ErrorResponse(
23088                ResponseValue::from_response(response).await?,
23089            )),
23090            _ => Err(Error::UnexpectedResponse(response)),
23091        }
23092    }
23093
23094    ///Generate hash sums
23095    ///
23096    ///Produces a hash sum listing for files under the given path using the
23097    /// requested hash algorithm.
23098    ///
23099    ///Sends a `POST` request to `/operations/hashsum`
23100    ///
23101    ///Arguments:
23102    /// - `async_`: Run the command asynchronously. Returns a job id
23103    ///   immediately.
23104    /// - `group`: Assign the request to a custom stats group.
23105    /// - `base64`: Set to true to emit hash values in base64 rather than
23106    ///   hexadecimal.
23107    /// - `download`: Set to true to force reading the data instead of using
23108    ///   remote checksums.
23109    /// - `fs`: Remote name or path to hash, such as `drive:` or `/`.
23110    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
23111    ///   supported name.
23112    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23113    ///   instead of 200.
23114    /// - `body`
23115    pub async fn operations_hashsum<'a>(
23116        &'a self,
23117        async_: Option<bool>,
23118        group: Option<&'a str>,
23119        base64: Option<bool>,
23120        download: Option<bool>,
23121        fs: Option<&'a str>,
23122        hash_type: Option<&'a str>,
23123        prefer: Option<types::OperationsHashsumPrefer>,
23124        body: &'a types::OperationsHashsumRequest,
23125    ) -> Result<ResponseValue<types::OperationsHashsumResponse>, Error<types::RcError>> {
23126        let url = format!("{}/operations/hashsum", self.baseurl,);
23127        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23128        header_map.append(
23129            ::reqwest::header::HeaderName::from_static("api-version"),
23130            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23131        );
23132        if let Some(value) = prefer {
23133            header_map.append("Prefer", value.to_string().try_into()?);
23134        }
23135
23136        #[allow(unused_mut)]
23137        let mut request = self
23138            .client
23139            .post(url)
23140            .header(
23141                ::reqwest::header::ACCEPT,
23142                ::reqwest::header::HeaderValue::from_static("application/json"),
23143            )
23144            .json(&body)
23145            .query(&progenitor_client::QueryParam::new("_async", &async_))
23146            .query(&progenitor_client::QueryParam::new("_group", &group))
23147            .query(&progenitor_client::QueryParam::new("base64", &base64))
23148            .query(&progenitor_client::QueryParam::new("download", &download))
23149            .query(&progenitor_client::QueryParam::new("fs", &fs))
23150            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
23151            .headers(header_map)
23152            .build()?;
23153        let info = OperationInfo {
23154            operation_id: "operations_hashsum",
23155        };
23156        self.pre(&mut request, &info).await?;
23157        let result = self.exec(request, &info).await;
23158        self.post(&result, &info).await?;
23159        let response = result?;
23160        match response.status().as_u16() {
23161            200u16 => ResponseValue::from_response(response).await,
23162            400u16..=499u16 => Err(Error::ErrorResponse(
23163                ResponseValue::from_response(response).await?,
23164            )),
23165            500u16..=599u16 => Err(Error::ErrorResponse(
23166                ResponseValue::from_response(response).await?,
23167            )),
23168            _ => Err(Error::UnexpectedResponse(response)),
23169        }
23170    }
23171
23172    ///Hash a single file
23173    ///
23174    ///Returns the hash of a single file using the specified hash algorithm.
23175    ///
23176    ///Sends a `POST` request to `/operations/hashsumfile`
23177    ///
23178    ///Arguments:
23179    /// - `async_`: Run the command asynchronously. Returns a job id
23180    ///   immediately.
23181    /// - `group`: Assign the request to a custom stats group.
23182    /// - `base64`: Set to true to emit the hash value in base64 rather than
23183    ///   hexadecimal.
23184    /// - `download`: Set to true to force reading the data instead of using
23185    ///   remote checksums.
23186    /// - `fs`: Remote name or path containing the file to hash.
23187    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
23188    ///   supported name.
23189    /// - `remote`: Path to the specific file within `fs` to hash.
23190    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23191    ///   instead of 200.
23192    /// - `body`
23193    pub async fn operations_hashsumfile<'a>(
23194        &'a self,
23195        async_: Option<bool>,
23196        group: Option<&'a str>,
23197        base64: Option<bool>,
23198        download: Option<bool>,
23199        fs: Option<&'a str>,
23200        hash_type: Option<&'a str>,
23201        remote: Option<&'a str>,
23202        prefer: Option<types::OperationsHashsumfilePrefer>,
23203        body: &'a types::OperationsHashsumfileRequest,
23204    ) -> Result<ResponseValue<types::OperationsHashsumfileResponse>, Error<types::RcError>> {
23205        let url = format!("{}/operations/hashsumfile", self.baseurl,);
23206        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23207        header_map.append(
23208            ::reqwest::header::HeaderName::from_static("api-version"),
23209            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23210        );
23211        if let Some(value) = prefer {
23212            header_map.append("Prefer", value.to_string().try_into()?);
23213        }
23214
23215        #[allow(unused_mut)]
23216        let mut request = self
23217            .client
23218            .post(url)
23219            .header(
23220                ::reqwest::header::ACCEPT,
23221                ::reqwest::header::HeaderValue::from_static("application/json"),
23222            )
23223            .json(&body)
23224            .query(&progenitor_client::QueryParam::new("_async", &async_))
23225            .query(&progenitor_client::QueryParam::new("_group", &group))
23226            .query(&progenitor_client::QueryParam::new("base64", &base64))
23227            .query(&progenitor_client::QueryParam::new("download", &download))
23228            .query(&progenitor_client::QueryParam::new("fs", &fs))
23229            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
23230            .query(&progenitor_client::QueryParam::new("remote", &remote))
23231            .headers(header_map)
23232            .build()?;
23233        let info = OperationInfo {
23234            operation_id: "operations_hashsumfile",
23235        };
23236        self.pre(&mut request, &info).await?;
23237        let result = self.exec(request, &info).await;
23238        self.post(&result, &info).await?;
23239        let response = result?;
23240        match response.status().as_u16() {
23241            200u16 => ResponseValue::from_response(response).await,
23242            400u16..=499u16 => Err(Error::ErrorResponse(
23243                ResponseValue::from_response(response).await?,
23244            )),
23245            500u16..=599u16 => Err(Error::ErrorResponse(
23246                ResponseValue::from_response(response).await?,
23247            )),
23248            _ => Err(Error::UnexpectedResponse(response)),
23249        }
23250    }
23251
23252    ///Move a single file
23253    ///
23254    ///Moves one object from a source remote and path to a destination remote
23255    /// and path.
23256    ///
23257    ///Sends a `POST` request to `/operations/movefile`
23258    ///
23259    ///Arguments:
23260    /// - `async_`: Run the command asynchronously. Returns a job id
23261    ///   immediately.
23262    /// - `group`: Assign the request to a custom stats group.
23263    /// - `dst_fs`: Destination remote name or path where the file will be
23264    ///   moved.
23265    /// - `dst_remote`: Destination path within `dstFs` for the moved object.
23266    /// - `src_fs`: Source remote name or path containing the file to move.
23267    /// - `src_remote`: Path to the source object within `srcFs`.
23268    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23269    ///   instead of 200.
23270    /// - `body`
23271    pub async fn operations_movefile<'a>(
23272        &'a self,
23273        async_: Option<bool>,
23274        group: Option<&'a str>,
23275        dst_fs: Option<&'a str>,
23276        dst_remote: Option<&'a str>,
23277        src_fs: Option<&'a str>,
23278        src_remote: Option<&'a str>,
23279        prefer: Option<types::OperationsMovefilePrefer>,
23280        body: &'a types::OperationsMovefileRequest,
23281    ) -> Result<
23282        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
23283        Error<types::RcError>,
23284    > {
23285        let url = format!("{}/operations/movefile", self.baseurl,);
23286        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23287        header_map.append(
23288            ::reqwest::header::HeaderName::from_static("api-version"),
23289            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23290        );
23291        if let Some(value) = prefer {
23292            header_map.append("Prefer", value.to_string().try_into()?);
23293        }
23294
23295        #[allow(unused_mut)]
23296        let mut request = self
23297            .client
23298            .post(url)
23299            .header(
23300                ::reqwest::header::ACCEPT,
23301                ::reqwest::header::HeaderValue::from_static("application/json"),
23302            )
23303            .json(&body)
23304            .query(&progenitor_client::QueryParam::new("_async", &async_))
23305            .query(&progenitor_client::QueryParam::new("_group", &group))
23306            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
23307            .query(&progenitor_client::QueryParam::new(
23308                "dstRemote",
23309                &dst_remote,
23310            ))
23311            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
23312            .query(&progenitor_client::QueryParam::new(
23313                "srcRemote",
23314                &src_remote,
23315            ))
23316            .headers(header_map)
23317            .build()?;
23318        let info = OperationInfo {
23319            operation_id: "operations_movefile",
23320        };
23321        self.pre(&mut request, &info).await?;
23322        let result = self.exec(request, &info).await;
23323        self.post(&result, &info).await?;
23324        let response = result?;
23325        match response.status().as_u16() {
23326            200u16 => ResponseValue::from_response(response).await,
23327            400u16..=499u16 => Err(Error::ErrorResponse(
23328                ResponseValue::from_response(response).await?,
23329            )),
23330            500u16..=599u16 => Err(Error::ErrorResponse(
23331                ResponseValue::from_response(response).await?,
23332            )),
23333            _ => Err(Error::UnexpectedResponse(response)),
23334        }
23335    }
23336
23337    ///Create or remove public link
23338    ///
23339    ///Creates a share URL for an object or removes an existing link when
23340    /// `unlink=true`.
23341    ///
23342    ///Sends a `POST` request to `/operations/publiclink`
23343    ///
23344    ///Arguments:
23345    /// - `async_`: Run the command asynchronously. Returns a job id
23346    ///   immediately.
23347    /// - `group`: Assign the request to a custom stats group.
23348    /// - `expire`: Optional expiration time for the public link, formatted as
23349    ///   supported by the backend.
23350    /// - `fs`: Remote name or path hosting the object for which to manage a
23351    ///   public link.
23352    /// - `remote`: Path within `fs` to the object for which to create or remove
23353    ///   a public link.
23354    /// - `unlink`: Set to true to remove an existing public link instead of
23355    ///   creating one.
23356    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23357    ///   instead of 200.
23358    /// - `body`
23359    pub async fn operations_publiclink<'a>(
23360        &'a self,
23361        async_: Option<bool>,
23362        group: Option<&'a str>,
23363        expire: Option<&'a str>,
23364        fs: Option<&'a str>,
23365        remote: Option<&'a str>,
23366        unlink: Option<bool>,
23367        prefer: Option<types::OperationsPubliclinkPrefer>,
23368        body: &'a types::OperationsPubliclinkRequest,
23369    ) -> Result<ResponseValue<types::OperationsPubliclinkResponse>, Error<types::RcError>> {
23370        let url = format!("{}/operations/publiclink", self.baseurl,);
23371        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23372        header_map.append(
23373            ::reqwest::header::HeaderName::from_static("api-version"),
23374            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23375        );
23376        if let Some(value) = prefer {
23377            header_map.append("Prefer", value.to_string().try_into()?);
23378        }
23379
23380        #[allow(unused_mut)]
23381        let mut request = self
23382            .client
23383            .post(url)
23384            .header(
23385                ::reqwest::header::ACCEPT,
23386                ::reqwest::header::HeaderValue::from_static("application/json"),
23387            )
23388            .json(&body)
23389            .query(&progenitor_client::QueryParam::new("_async", &async_))
23390            .query(&progenitor_client::QueryParam::new("_group", &group))
23391            .query(&progenitor_client::QueryParam::new("expire", &expire))
23392            .query(&progenitor_client::QueryParam::new("fs", &fs))
23393            .query(&progenitor_client::QueryParam::new("remote", &remote))
23394            .query(&progenitor_client::QueryParam::new("unlink", &unlink))
23395            .headers(header_map)
23396            .build()?;
23397        let info = OperationInfo {
23398            operation_id: "operations_publiclink",
23399        };
23400        self.pre(&mut request, &info).await?;
23401        let result = self.exec(request, &info).await;
23402        self.post(&result, &info).await?;
23403        let response = result?;
23404        match response.status().as_u16() {
23405            200u16 => ResponseValue::from_response(response).await,
23406            400u16..=499u16 => Err(Error::ErrorResponse(
23407                ResponseValue::from_response(response).await?,
23408            )),
23409            500u16..=599u16 => Err(Error::ErrorResponse(
23410                ResponseValue::from_response(response).await?,
23411            )),
23412            _ => Err(Error::UnexpectedResponse(response)),
23413        }
23414    }
23415
23416    ///Remove empty directories
23417    ///
23418    ///Deletes empty subdirectories beneath the specified path, optionally
23419    /// leaving the root.
23420    ///
23421    ///Sends a `POST` request to `/operations/rmdirs`
23422    ///
23423    ///Arguments:
23424    /// - `async_`: Run the command asynchronously. Returns a job id
23425    ///   immediately.
23426    /// - `group`: Assign the request to a custom stats group.
23427    /// - `fs`: Remote name or path to scan for empty directories.
23428    /// - `leave_root`: Set to true to preserve the top-level directory even if
23429    ///   empty.
23430    /// - `remote`: Path within `fs` whose empty subdirectories should be
23431    ///   removed.
23432    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23433    ///   instead of 200.
23434    /// - `body`
23435    pub async fn operations_rmdirs<'a>(
23436        &'a self,
23437        async_: Option<bool>,
23438        group: Option<&'a str>,
23439        fs: Option<&'a str>,
23440        leave_root: Option<bool>,
23441        remote: Option<&'a str>,
23442        prefer: Option<types::OperationsRmdirsPrefer>,
23443        body: &'a types::OperationsRmdirsRequest,
23444    ) -> Result<
23445        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
23446        Error<types::RcError>,
23447    > {
23448        let url = format!("{}/operations/rmdirs", self.baseurl,);
23449        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23450        header_map.append(
23451            ::reqwest::header::HeaderName::from_static("api-version"),
23452            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23453        );
23454        if let Some(value) = prefer {
23455            header_map.append("Prefer", value.to_string().try_into()?);
23456        }
23457
23458        #[allow(unused_mut)]
23459        let mut request = self
23460            .client
23461            .post(url)
23462            .header(
23463                ::reqwest::header::ACCEPT,
23464                ::reqwest::header::HeaderValue::from_static("application/json"),
23465            )
23466            .json(&body)
23467            .query(&progenitor_client::QueryParam::new("_async", &async_))
23468            .query(&progenitor_client::QueryParam::new("_group", &group))
23469            .query(&progenitor_client::QueryParam::new("fs", &fs))
23470            .query(&progenitor_client::QueryParam::new(
23471                "leaveRoot",
23472                &leave_root,
23473            ))
23474            .query(&progenitor_client::QueryParam::new("remote", &remote))
23475            .headers(header_map)
23476            .build()?;
23477        let info = OperationInfo {
23478            operation_id: "operations_rmdirs",
23479        };
23480        self.pre(&mut request, &info).await?;
23481        let result = self.exec(request, &info).await;
23482        self.post(&result, &info).await?;
23483        let response = result?;
23484        match response.status().as_u16() {
23485            200u16 => ResponseValue::from_response(response).await,
23486            400u16..=499u16 => Err(Error::ErrorResponse(
23487                ResponseValue::from_response(response).await?,
23488            )),
23489            500u16..=599u16 => Err(Error::ErrorResponse(
23490                ResponseValue::from_response(response).await?,
23491            )),
23492            _ => Err(Error::UnexpectedResponse(response)),
23493        }
23494    }
23495
23496    ///Change storage tier
23497    ///
23498    ///Updates the storage class or tier for every object in the specified
23499    /// remote path.
23500    ///
23501    ///Sends a `POST` request to `/operations/settier`
23502    ///
23503    ///Arguments:
23504    /// - `async_`: Run the command asynchronously. Returns a job id
23505    ///   immediately.
23506    /// - `group`: Assign the request to a custom stats group.
23507    /// - `fs`: Remote name or path whose storage class tier should be changed.
23508    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23509    ///   instead of 200.
23510    /// - `body`
23511    pub async fn operations_settier<'a>(
23512        &'a self,
23513        async_: Option<bool>,
23514        group: Option<&'a str>,
23515        fs: Option<&'a str>,
23516        prefer: Option<types::OperationsSettierPrefer>,
23517        body: &'a types::OperationsSettierRequest,
23518    ) -> Result<
23519        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
23520        Error<types::RcError>,
23521    > {
23522        let url = format!("{}/operations/settier", self.baseurl,);
23523        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23524        header_map.append(
23525            ::reqwest::header::HeaderName::from_static("api-version"),
23526            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23527        );
23528        if let Some(value) = prefer {
23529            header_map.append("Prefer", value.to_string().try_into()?);
23530        }
23531
23532        #[allow(unused_mut)]
23533        let mut request = self
23534            .client
23535            .post(url)
23536            .header(
23537                ::reqwest::header::ACCEPT,
23538                ::reqwest::header::HeaderValue::from_static("application/json"),
23539            )
23540            .json(&body)
23541            .query(&progenitor_client::QueryParam::new("_async", &async_))
23542            .query(&progenitor_client::QueryParam::new("_group", &group))
23543            .query(&progenitor_client::QueryParam::new("fs", &fs))
23544            .headers(header_map)
23545            .build()?;
23546        let info = OperationInfo {
23547            operation_id: "operations_settier",
23548        };
23549        self.pre(&mut request, &info).await?;
23550        let result = self.exec(request, &info).await;
23551        self.post(&result, &info).await?;
23552        let response = result?;
23553        match response.status().as_u16() {
23554            200u16 => ResponseValue::from_response(response).await,
23555            400u16..=499u16 => Err(Error::ErrorResponse(
23556                ResponseValue::from_response(response).await?,
23557            )),
23558            500u16..=599u16 => Err(Error::ErrorResponse(
23559                ResponseValue::from_response(response).await?,
23560            )),
23561            _ => Err(Error::UnexpectedResponse(response)),
23562        }
23563    }
23564
23565    ///Change file storage tier
23566    ///
23567    ///Updates the storage class or tier for a single object.
23568    ///
23569    ///Sends a `POST` request to `/operations/settierfile`
23570    ///
23571    ///Arguments:
23572    /// - `async_`: Run the command asynchronously. Returns a job id
23573    ///   immediately.
23574    /// - `group`: Assign the request to a custom stats group.
23575    /// - `fs`: Remote name or path that contains the object whose tier should
23576    ///   change.
23577    /// - `remote`: Path within `fs` to the object whose storage class tier
23578    ///   should be updated.
23579    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23580    ///   instead of 200.
23581    /// - `body`
23582    pub async fn operations_settierfile<'a>(
23583        &'a self,
23584        async_: Option<bool>,
23585        group: Option<&'a str>,
23586        fs: Option<&'a str>,
23587        remote: Option<&'a str>,
23588        prefer: Option<types::OperationsSettierfilePrefer>,
23589        body: &'a types::OperationsSettierfileRequest,
23590    ) -> Result<
23591        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
23592        Error<types::RcError>,
23593    > {
23594        let url = format!("{}/operations/settierfile", self.baseurl,);
23595        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23596        header_map.append(
23597            ::reqwest::header::HeaderName::from_static("api-version"),
23598            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23599        );
23600        if let Some(value) = prefer {
23601            header_map.append("Prefer", value.to_string().try_into()?);
23602        }
23603
23604        #[allow(unused_mut)]
23605        let mut request = self
23606            .client
23607            .post(url)
23608            .header(
23609                ::reqwest::header::ACCEPT,
23610                ::reqwest::header::HeaderValue::from_static("application/json"),
23611            )
23612            .json(&body)
23613            .query(&progenitor_client::QueryParam::new("_async", &async_))
23614            .query(&progenitor_client::QueryParam::new("_group", &group))
23615            .query(&progenitor_client::QueryParam::new("fs", &fs))
23616            .query(&progenitor_client::QueryParam::new("remote", &remote))
23617            .headers(header_map)
23618            .build()?;
23619        let info = OperationInfo {
23620            operation_id: "operations_settierfile",
23621        };
23622        self.pre(&mut request, &info).await?;
23623        let result = self.exec(request, &info).await;
23624        self.post(&result, &info).await?;
23625        let response = result?;
23626        match response.status().as_u16() {
23627            200u16 => ResponseValue::from_response(response).await,
23628            400u16..=499u16 => Err(Error::ErrorResponse(
23629                ResponseValue::from_response(response).await?,
23630            )),
23631            500u16..=599u16 => Err(Error::ErrorResponse(
23632                ResponseValue::from_response(response).await?,
23633            )),
23634            _ => Err(Error::UnexpectedResponse(response)),
23635        }
23636    }
23637
23638    ///Count remote size
23639    ///
23640    ///Reports total size, file count, and number of objects without size
23641    /// metadata.
23642    ///
23643    ///Sends a `POST` request to `/operations/size`
23644    ///
23645    ///Arguments:
23646    /// - `async_`: Run the command asynchronously. Returns a job id
23647    ///   immediately.
23648    /// - `group`: Assign the request to a custom stats group.
23649    /// - `fs`: Remote name or path to measure aggregate size information for.
23650    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23651    ///   instead of 200.
23652    /// - `body`
23653    pub async fn operations_size<'a>(
23654        &'a self,
23655        async_: Option<bool>,
23656        group: Option<&'a str>,
23657        fs: Option<&'a str>,
23658        prefer: Option<types::OperationsSizePrefer>,
23659        body: &'a types::OperationsSizeRequest,
23660    ) -> Result<ResponseValue<types::OperationsSizeResponse>, Error<types::RcError>> {
23661        let url = format!("{}/operations/size", self.baseurl,);
23662        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23663        header_map.append(
23664            ::reqwest::header::HeaderName::from_static("api-version"),
23665            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23666        );
23667        if let Some(value) = prefer {
23668            header_map.append("Prefer", value.to_string().try_into()?);
23669        }
23670
23671        #[allow(unused_mut)]
23672        let mut request = self
23673            .client
23674            .post(url)
23675            .header(
23676                ::reqwest::header::ACCEPT,
23677                ::reqwest::header::HeaderValue::from_static("application/json"),
23678            )
23679            .json(&body)
23680            .query(&progenitor_client::QueryParam::new("_async", &async_))
23681            .query(&progenitor_client::QueryParam::new("_group", &group))
23682            .query(&progenitor_client::QueryParam::new("fs", &fs))
23683            .headers(header_map)
23684            .build()?;
23685        let info = OperationInfo {
23686            operation_id: "operations_size",
23687        };
23688        self.pre(&mut request, &info).await?;
23689        let result = self.exec(request, &info).await;
23690        self.post(&result, &info).await?;
23691        let response = result?;
23692        match response.status().as_u16() {
23693            200u16 => ResponseValue::from_response(response).await,
23694            400u16..=499u16 => Err(Error::ErrorResponse(
23695                ResponseValue::from_response(response).await?,
23696            )),
23697            500u16..=599u16 => Err(Error::ErrorResponse(
23698                ResponseValue::from_response(response).await?,
23699            )),
23700            _ => Err(Error::UnexpectedResponse(response)),
23701        }
23702    }
23703
23704    ///Get or update bandwidth limits
23705    ///
23706    ///Reads the current bandwidth limit or applies a new schedule string, just
23707    /// like `rclone rc core/bwlimit`.
23708    ///
23709    ///Sends a `POST` request to `/core/bwlimit`
23710    ///
23711    ///Arguments:
23712    /// - `async_`: Run the command asynchronously. Returns a job id
23713    ///   immediately.
23714    /// - `group`: Assign the request to a custom stats group.
23715    /// - `rate`: Bandwidth limit to apply, for example `off`, `5M`, or a
23716    ///   schedule string.
23717    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23718    ///   instead of 200.
23719    /// - `body`
23720    pub async fn core_bwlimit<'a>(
23721        &'a self,
23722        async_: Option<bool>,
23723        group: Option<&'a str>,
23724        rate: Option<&'a str>,
23725        prefer: Option<types::CoreBwlimitPrefer>,
23726        body: &'a types::CoreBwlimitRequest,
23727    ) -> Result<ResponseValue<types::CoreBwlimitResponse>, Error<types::RcError>> {
23728        let url = format!("{}/core/bwlimit", self.baseurl,);
23729        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23730        header_map.append(
23731            ::reqwest::header::HeaderName::from_static("api-version"),
23732            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23733        );
23734        if let Some(value) = prefer {
23735            header_map.append("Prefer", value.to_string().try_into()?);
23736        }
23737
23738        #[allow(unused_mut)]
23739        let mut request = self
23740            .client
23741            .post(url)
23742            .header(
23743                ::reqwest::header::ACCEPT,
23744                ::reqwest::header::HeaderValue::from_static("application/json"),
23745            )
23746            .json(&body)
23747            .query(&progenitor_client::QueryParam::new("_async", &async_))
23748            .query(&progenitor_client::QueryParam::new("_group", &group))
23749            .query(&progenitor_client::QueryParam::new("rate", &rate))
23750            .headers(header_map)
23751            .build()?;
23752        let info = OperationInfo {
23753            operation_id: "core_bwlimit",
23754        };
23755        self.pre(&mut request, &info).await?;
23756        let result = self.exec(request, &info).await;
23757        self.post(&result, &info).await?;
23758        let response = result?;
23759        match response.status().as_u16() {
23760            200u16 => ResponseValue::from_response(response).await,
23761            400u16..=499u16 => Err(Error::ErrorResponse(
23762                ResponseValue::from_response(response).await?,
23763            )),
23764            500u16..=599u16 => Err(Error::ErrorResponse(
23765                ResponseValue::from_response(response).await?,
23766            )),
23767            _ => Err(Error::UnexpectedResponse(response)),
23768        }
23769    }
23770
23771    ///Run an rclone command
23772    ///
23773    ///Executes a standard rclone CLI command remotely and streams or returns
23774    /// its output.
23775    ///
23776    ///Sends a `POST` request to `/core/command`
23777    ///
23778    ///Arguments:
23779    /// - `async_`: Run the command asynchronously. Returns a job id
23780    ///   immediately.
23781    /// - `group`: Assign the request to a custom stats group.
23782    /// - `arg`: Optional positional arguments for the command. Repeat to supply
23783    ///   multiple values.
23784    /// - `command`: Name of the rclone command to execute, for example `ls` or
23785    ///   `lsf`.
23786    /// - `opt`: Optional command options encoded as a JSON string.
23787    /// - `return_type`: Controls how output is returned; accepts
23788    ///   `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
23789    ///   `STREAM_ONLY_STDERR`.
23790    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23791    ///   instead of 200.
23792    /// - `body`
23793    pub async fn core_command<'a>(
23794        &'a self,
23795        async_: Option<bool>,
23796        group: Option<&'a str>,
23797        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
23798        command: Option<&'a str>,
23799        opt: Option<&'a str>,
23800        return_type: Option<&'a str>,
23801        prefer: Option<types::CoreCommandPrefer>,
23802        body: &'a types::CoreCommandRequest,
23803    ) -> Result<ResponseValue<types::CoreCommandResponse>, Error<types::RcError>> {
23804        let url = format!("{}/core/command", self.baseurl,);
23805        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23806        header_map.append(
23807            ::reqwest::header::HeaderName::from_static("api-version"),
23808            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23809        );
23810        if let Some(value) = prefer {
23811            header_map.append("Prefer", value.to_string().try_into()?);
23812        }
23813
23814        #[allow(unused_mut)]
23815        let mut request = self
23816            .client
23817            .post(url)
23818            .header(
23819                ::reqwest::header::ACCEPT,
23820                ::reqwest::header::HeaderValue::from_static("application/json"),
23821            )
23822            .json(&body)
23823            .query(&progenitor_client::QueryParam::new("_async", &async_))
23824            .query(&progenitor_client::QueryParam::new("_group", &group))
23825            .query(&progenitor_client::QueryParam::new("arg", &arg))
23826            .query(&progenitor_client::QueryParam::new("command", &command))
23827            .query(&progenitor_client::QueryParam::new("opt", &opt))
23828            .query(&progenitor_client::QueryParam::new(
23829                "returnType",
23830                &return_type,
23831            ))
23832            .headers(header_map)
23833            .build()?;
23834        let info = OperationInfo {
23835            operation_id: "core_command",
23836        };
23837        self.pre(&mut request, &info).await?;
23838        let result = self.exec(request, &info).await;
23839        self.post(&result, &info).await?;
23840        let response = result?;
23841        match response.status().as_u16() {
23842            200u16 => ResponseValue::from_response(response).await,
23843            400u16..=499u16 => Err(Error::ErrorResponse(
23844                ResponseValue::from_response(response).await?,
23845            )),
23846            500u16..=599u16 => Err(Error::ErrorResponse(
23847                ResponseValue::from_response(response).await?,
23848            )),
23849            _ => Err(Error::UnexpectedResponse(response)),
23850        }
23851    }
23852
23853    ///List locally accessible paths
23854    ///
23855    ///Returns a list of locally accessible paths including mount points, user
23856    /// directories, and removable volumes.
23857    ///
23858    ///Sends a `POST` request to `/core/disks`
23859    ///
23860    ///Arguments:
23861    /// - `async_`: Run the command asynchronously. Returns a job id
23862    ///   immediately.
23863    /// - `group`: Assign the request to a custom stats group.
23864    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23865    ///   instead of 200.
23866    /// - `body`
23867    pub async fn core_disks<'a>(
23868        &'a self,
23869        async_: Option<bool>,
23870        group: Option<&'a str>,
23871        prefer: Option<types::CoreDisksPrefer>,
23872        body: &'a types::CoreDisksRequest,
23873    ) -> Result<ResponseValue<types::CoreDisksResponse>, Error<types::RcError>> {
23874        let url = format!("{}/core/disks", self.baseurl,);
23875        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23876        header_map.append(
23877            ::reqwest::header::HeaderName::from_static("api-version"),
23878            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23879        );
23880        if let Some(value) = prefer {
23881            header_map.append("Prefer", value.to_string().try_into()?);
23882        }
23883
23884        #[allow(unused_mut)]
23885        let mut request = self
23886            .client
23887            .post(url)
23888            .header(
23889                ::reqwest::header::ACCEPT,
23890                ::reqwest::header::HeaderValue::from_static("application/json"),
23891            )
23892            .json(&body)
23893            .query(&progenitor_client::QueryParam::new("_async", &async_))
23894            .query(&progenitor_client::QueryParam::new("_group", &group))
23895            .headers(header_map)
23896            .build()?;
23897        let info = OperationInfo {
23898            operation_id: "core_disks",
23899        };
23900        self.pre(&mut request, &info).await?;
23901        let result = self.exec(request, &info).await;
23902        self.post(&result, &info).await?;
23903        let response = result?;
23904        match response.status().as_u16() {
23905            200u16 => ResponseValue::from_response(response).await,
23906            400u16..=499u16 => Err(Error::ErrorResponse(
23907                ResponseValue::from_response(response).await?,
23908            )),
23909            500u16..=599u16 => Err(Error::ErrorResponse(
23910                ResponseValue::from_response(response).await?,
23911            )),
23912            _ => Err(Error::UnexpectedResponse(response)),
23913        }
23914    }
23915
23916    ///Report disk usage
23917    ///
23918    ///Returns disk usage statistics for the supplied local directory (defaults
23919    /// to the cache dir).
23920    ///
23921    ///Sends a `POST` request to `/core/du`
23922    ///
23923    ///Arguments:
23924    /// - `async_`: Run the command asynchronously. Returns a job id
23925    ///   immediately.
23926    /// - `group`: Assign the request to a custom stats group.
23927    /// - `dir`: Local directory path to report disk usage for. Defaults to the
23928    ///   rclone cache directory when omitted.
23929    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23930    ///   instead of 200.
23931    /// - `body`
23932    pub async fn core_du<'a>(
23933        &'a self,
23934        async_: Option<bool>,
23935        group: Option<&'a str>,
23936        dir: Option<&'a str>,
23937        prefer: Option<types::CoreDuPrefer>,
23938        body: &'a types::CoreDuRequest,
23939    ) -> Result<ResponseValue<types::CoreDuResponse>, Error<types::RcError>> {
23940        let url = format!("{}/core/du", self.baseurl,);
23941        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
23942        header_map.append(
23943            ::reqwest::header::HeaderName::from_static("api-version"),
23944            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
23945        );
23946        if let Some(value) = prefer {
23947            header_map.append("Prefer", value.to_string().try_into()?);
23948        }
23949
23950        #[allow(unused_mut)]
23951        let mut request = self
23952            .client
23953            .post(url)
23954            .header(
23955                ::reqwest::header::ACCEPT,
23956                ::reqwest::header::HeaderValue::from_static("application/json"),
23957            )
23958            .json(&body)
23959            .query(&progenitor_client::QueryParam::new("_async", &async_))
23960            .query(&progenitor_client::QueryParam::new("_group", &group))
23961            .query(&progenitor_client::QueryParam::new("dir", &dir))
23962            .headers(header_map)
23963            .build()?;
23964        let info = OperationInfo {
23965            operation_id: "core_du",
23966        };
23967        self.pre(&mut request, &info).await?;
23968        let result = self.exec(request, &info).await;
23969        self.post(&result, &info).await?;
23970        let response = result?;
23971        match response.status().as_u16() {
23972            200u16 => ResponseValue::from_response(response).await,
23973            400u16..=499u16 => Err(Error::ErrorResponse(
23974                ResponseValue::from_response(response).await?,
23975            )),
23976            500u16..=599u16 => Err(Error::ErrorResponse(
23977                ResponseValue::from_response(response).await?,
23978            )),
23979            _ => Err(Error::UnexpectedResponse(response)),
23980        }
23981    }
23982
23983    ///Force garbage collection
23984    ///
23985    ///Triggers Go's garbage collector to release unused memory.
23986    ///
23987    ///Sends a `POST` request to `/core/gc`
23988    ///
23989    ///Arguments:
23990    /// - `async_`: Run the command asynchronously. Returns a job id
23991    ///   immediately.
23992    /// - `group`: Assign the request to a custom stats group.
23993    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
23994    ///   instead of 200.
23995    /// - `body`
23996    pub async fn core_gc<'a>(
23997        &'a self,
23998        async_: Option<bool>,
23999        group: Option<&'a str>,
24000        prefer: Option<types::CoreGcPrefer>,
24001        body: &'a types::CoreGcRequest,
24002    ) -> Result<
24003        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24004        Error<types::RcError>,
24005    > {
24006        let url = format!("{}/core/gc", self.baseurl,);
24007        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24008        header_map.append(
24009            ::reqwest::header::HeaderName::from_static("api-version"),
24010            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24011        );
24012        if let Some(value) = prefer {
24013            header_map.append("Prefer", value.to_string().try_into()?);
24014        }
24015
24016        #[allow(unused_mut)]
24017        let mut request = self
24018            .client
24019            .post(url)
24020            .header(
24021                ::reqwest::header::ACCEPT,
24022                ::reqwest::header::HeaderValue::from_static("application/json"),
24023            )
24024            .json(&body)
24025            .query(&progenitor_client::QueryParam::new("_async", &async_))
24026            .query(&progenitor_client::QueryParam::new("_group", &group))
24027            .headers(header_map)
24028            .build()?;
24029        let info = OperationInfo {
24030            operation_id: "core_gc",
24031        };
24032        self.pre(&mut request, &info).await?;
24033        let result = self.exec(request, &info).await;
24034        self.post(&result, &info).await?;
24035        let response = result?;
24036        match response.status().as_u16() {
24037            200u16 => ResponseValue::from_response(response).await,
24038            400u16..=499u16 => Err(Error::ErrorResponse(
24039                ResponseValue::from_response(response).await?,
24040            )),
24041            500u16..=599u16 => Err(Error::ErrorResponse(
24042                ResponseValue::from_response(response).await?,
24043            )),
24044            _ => Err(Error::UnexpectedResponse(response)),
24045        }
24046    }
24047
24048    ///List stats groups
24049    ///
24050    ///Lists stats groups currently tracked by rclone.
24051    ///
24052    ///Sends a `POST` request to `/core/group-list`
24053    ///
24054    ///Arguments:
24055    /// - `async_`: Run the command asynchronously. Returns a job id
24056    ///   immediately.
24057    /// - `group`: Assign the request to a custom stats group.
24058    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24059    ///   instead of 200.
24060    /// - `body`
24061    pub async fn core_group_list<'a>(
24062        &'a self,
24063        async_: Option<bool>,
24064        group: Option<&'a str>,
24065        prefer: Option<types::CoreGroupListPrefer>,
24066        body: &'a types::CoreGroupListRequest,
24067    ) -> Result<ResponseValue<types::CoreGroupListResponse>, Error<types::RcError>> {
24068        let url = format!("{}/core/group-list", self.baseurl,);
24069        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24070        header_map.append(
24071            ::reqwest::header::HeaderName::from_static("api-version"),
24072            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24073        );
24074        if let Some(value) = prefer {
24075            header_map.append("Prefer", value.to_string().try_into()?);
24076        }
24077
24078        #[allow(unused_mut)]
24079        let mut request = self
24080            .client
24081            .post(url)
24082            .header(
24083                ::reqwest::header::ACCEPT,
24084                ::reqwest::header::HeaderValue::from_static("application/json"),
24085            )
24086            .json(&body)
24087            .query(&progenitor_client::QueryParam::new("_async", &async_))
24088            .query(&progenitor_client::QueryParam::new("_group", &group))
24089            .headers(header_map)
24090            .build()?;
24091        let info = OperationInfo {
24092            operation_id: "core_group_list",
24093        };
24094        self.pre(&mut request, &info).await?;
24095        let result = self.exec(request, &info).await;
24096        self.post(&result, &info).await?;
24097        let response = result?;
24098        match response.status().as_u16() {
24099            200u16 => ResponseValue::from_response(response).await,
24100            400u16..=499u16 => Err(Error::ErrorResponse(
24101                ResponseValue::from_response(response).await?,
24102            )),
24103            500u16..=599u16 => Err(Error::ErrorResponse(
24104                ResponseValue::from_response(response).await?,
24105            )),
24106            _ => Err(Error::UnexpectedResponse(response)),
24107        }
24108    }
24109
24110    ///Fetch runtime memory stats
24111    ///
24112    ///Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
24113    ///
24114    ///Sends a `POST` request to `/core/memstats`
24115    ///
24116    ///Arguments:
24117    /// - `async_`: Run the command asynchronously. Returns a job id
24118    ///   immediately.
24119    /// - `group`: Assign the request to a custom stats group.
24120    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24121    ///   instead of 200.
24122    /// - `body`
24123    pub async fn core_memstats<'a>(
24124        &'a self,
24125        async_: Option<bool>,
24126        group: Option<&'a str>,
24127        prefer: Option<types::CoreMemstatsPrefer>,
24128        body: &'a types::CoreMemstatsRequest,
24129    ) -> Result<
24130        ResponseValue<::std::collections::HashMap<::std::string::String, f64>>,
24131        Error<types::RcError>,
24132    > {
24133        let url = format!("{}/core/memstats", self.baseurl,);
24134        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24135        header_map.append(
24136            ::reqwest::header::HeaderName::from_static("api-version"),
24137            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24138        );
24139        if let Some(value) = prefer {
24140            header_map.append("Prefer", value.to_string().try_into()?);
24141        }
24142
24143        #[allow(unused_mut)]
24144        let mut request = self
24145            .client
24146            .post(url)
24147            .header(
24148                ::reqwest::header::ACCEPT,
24149                ::reqwest::header::HeaderValue::from_static("application/json"),
24150            )
24151            .json(&body)
24152            .query(&progenitor_client::QueryParam::new("_async", &async_))
24153            .query(&progenitor_client::QueryParam::new("_group", &group))
24154            .headers(header_map)
24155            .build()?;
24156        let info = OperationInfo {
24157            operation_id: "core_memstats",
24158        };
24159        self.pre(&mut request, &info).await?;
24160        let result = self.exec(request, &info).await;
24161        self.post(&result, &info).await?;
24162        let response = result?;
24163        match response.status().as_u16() {
24164            200u16 => ResponseValue::from_response(response).await,
24165            400u16..=499u16 => Err(Error::ErrorResponse(
24166                ResponseValue::from_response(response).await?,
24167            )),
24168            500u16..=599u16 => Err(Error::ErrorResponse(
24169                ResponseValue::from_response(response).await?,
24170            )),
24171            _ => Err(Error::UnexpectedResponse(response)),
24172        }
24173    }
24174
24175    ///Obscure a clear string
24176    ///
24177    ///Obscures a plain-text secret for inclusion in `rclone.conf`.
24178    ///
24179    ///Sends a `POST` request to `/core/obscure`
24180    ///
24181    ///Arguments:
24182    /// - `async_`: Run the command asynchronously. Returns a job id
24183    ///   immediately.
24184    /// - `group`: Assign the request to a custom stats group.
24185    /// - `clear`: Plain-text string to obscure for storage in the config file.
24186    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24187    ///   instead of 200.
24188    /// - `body`
24189    pub async fn core_obscure<'a>(
24190        &'a self,
24191        async_: Option<bool>,
24192        group: Option<&'a str>,
24193        clear: Option<&'a str>,
24194        prefer: Option<types::CoreObscurePrefer>,
24195        body: &'a types::CoreObscureRequest,
24196    ) -> Result<ResponseValue<types::CoreObscureResponse>, Error<types::RcError>> {
24197        let url = format!("{}/core/obscure", self.baseurl,);
24198        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24199        header_map.append(
24200            ::reqwest::header::HeaderName::from_static("api-version"),
24201            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24202        );
24203        if let Some(value) = prefer {
24204            header_map.append("Prefer", value.to_string().try_into()?);
24205        }
24206
24207        #[allow(unused_mut)]
24208        let mut request = self
24209            .client
24210            .post(url)
24211            .header(
24212                ::reqwest::header::ACCEPT,
24213                ::reqwest::header::HeaderValue::from_static("application/json"),
24214            )
24215            .json(&body)
24216            .query(&progenitor_client::QueryParam::new("_async", &async_))
24217            .query(&progenitor_client::QueryParam::new("_group", &group))
24218            .query(&progenitor_client::QueryParam::new("clear", &clear))
24219            .headers(header_map)
24220            .build()?;
24221        let info = OperationInfo {
24222            operation_id: "core_obscure",
24223        };
24224        self.pre(&mut request, &info).await?;
24225        let result = self.exec(request, &info).await;
24226        self.post(&result, &info).await?;
24227        let response = result?;
24228        match response.status().as_u16() {
24229            200u16 => ResponseValue::from_response(response).await,
24230            400u16..=499u16 => Err(Error::ErrorResponse(
24231                ResponseValue::from_response(response).await?,
24232            )),
24233            500u16..=599u16 => Err(Error::ErrorResponse(
24234                ResponseValue::from_response(response).await?,
24235            )),
24236            _ => Err(Error::UnexpectedResponse(response)),
24237        }
24238    }
24239
24240    ///Return rclone PID
24241    ///
24242    ///Returns the process ID of the running rclone instance.
24243    ///
24244    ///Sends a `POST` request to `/core/pid`
24245    ///
24246    ///Arguments:
24247    /// - `async_`: Run the command asynchronously. Returns a job id
24248    ///   immediately.
24249    /// - `group`: Assign the request to a custom stats group.
24250    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24251    ///   instead of 200.
24252    /// - `body`
24253    pub async fn core_pid<'a>(
24254        &'a self,
24255        async_: Option<bool>,
24256        group: Option<&'a str>,
24257        prefer: Option<types::CorePidPrefer>,
24258        body: &'a types::CorePidRequest,
24259    ) -> Result<ResponseValue<types::CorePidResponse>, Error<types::RcError>> {
24260        let url = format!("{}/core/pid", self.baseurl,);
24261        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24262        header_map.append(
24263            ::reqwest::header::HeaderName::from_static("api-version"),
24264            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24265        );
24266        if let Some(value) = prefer {
24267            header_map.append("Prefer", value.to_string().try_into()?);
24268        }
24269
24270        #[allow(unused_mut)]
24271        let mut request = self
24272            .client
24273            .post(url)
24274            .header(
24275                ::reqwest::header::ACCEPT,
24276                ::reqwest::header::HeaderValue::from_static("application/json"),
24277            )
24278            .json(&body)
24279            .query(&progenitor_client::QueryParam::new("_async", &async_))
24280            .query(&progenitor_client::QueryParam::new("_group", &group))
24281            .headers(header_map)
24282            .build()?;
24283        let info = OperationInfo {
24284            operation_id: "core_pid",
24285        };
24286        self.pre(&mut request, &info).await?;
24287        let result = self.exec(request, &info).await;
24288        self.post(&result, &info).await?;
24289        let response = result?;
24290        match response.status().as_u16() {
24291            200u16 => ResponseValue::from_response(response).await,
24292            400u16..=499u16 => Err(Error::ErrorResponse(
24293                ResponseValue::from_response(response).await?,
24294            )),
24295            500u16..=599u16 => Err(Error::ErrorResponse(
24296                ResponseValue::from_response(response).await?,
24297            )),
24298            _ => Err(Error::UnexpectedResponse(response)),
24299        }
24300    }
24301
24302    ///Terminate rclone
24303    ///
24304    ///Stops the rclone process, optionally supplying an exit code.
24305    ///
24306    ///Sends a `POST` request to `/core/quit`
24307    ///
24308    ///Arguments:
24309    /// - `async_`: Run the command asynchronously. Returns a job id
24310    ///   immediately.
24311    /// - `group`: Assign the request to a custom stats group.
24312    /// - `exit_code`: Optional exit code to use when terminating the rclone
24313    ///   process.
24314    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24315    ///   instead of 200.
24316    /// - `body`
24317    pub async fn core_quit<'a>(
24318        &'a self,
24319        async_: Option<bool>,
24320        group: Option<&'a str>,
24321        exit_code: Option<i64>,
24322        prefer: Option<types::CoreQuitPrefer>,
24323        body: &'a types::CoreQuitRequest,
24324    ) -> Result<
24325        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24326        Error<types::RcError>,
24327    > {
24328        let url = format!("{}/core/quit", self.baseurl,);
24329        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24330        header_map.append(
24331            ::reqwest::header::HeaderName::from_static("api-version"),
24332            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24333        );
24334        if let Some(value) = prefer {
24335            header_map.append("Prefer", value.to_string().try_into()?);
24336        }
24337
24338        #[allow(unused_mut)]
24339        let mut request = self
24340            .client
24341            .post(url)
24342            .header(
24343                ::reqwest::header::ACCEPT,
24344                ::reqwest::header::HeaderValue::from_static("application/json"),
24345            )
24346            .json(&body)
24347            .query(&progenitor_client::QueryParam::new("_async", &async_))
24348            .query(&progenitor_client::QueryParam::new("_group", &group))
24349            .query(&progenitor_client::QueryParam::new("exitCode", &exit_code))
24350            .headers(header_map)
24351            .build()?;
24352        let info = OperationInfo {
24353            operation_id: "core_quit",
24354        };
24355        self.pre(&mut request, &info).await?;
24356        let result = self.exec(request, &info).await;
24357        self.post(&result, &info).await?;
24358        let response = result?;
24359        match response.status().as_u16() {
24360            200u16 => ResponseValue::from_response(response).await,
24361            400u16..=499u16 => Err(Error::ErrorResponse(
24362                ResponseValue::from_response(response).await?,
24363            )),
24364            500u16..=599u16 => Err(Error::ErrorResponse(
24365                ResponseValue::from_response(response).await?,
24366            )),
24367            _ => Err(Error::UnexpectedResponse(response)),
24368        }
24369    }
24370
24371    ///Delete stats group
24372    ///
24373    ///Deletes the counters associated with a specific stats group.
24374    ///
24375    ///Sends a `POST` request to `/core/stats-delete`
24376    ///
24377    ///Arguments:
24378    /// - `async_`: Run the command asynchronously. Returns a job id
24379    ///   immediately.
24380    /// - `group`: Assign the request to a custom stats group.
24381    /// - `group`: Stats group identifier to remove.
24382    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24383    ///   instead of 200.
24384    /// - `body`
24385    pub async fn core_stats_delete<'a>(
24386        &'a self,
24387        async_: Option<bool>,
24388        group_: Option<&'a str>,
24389        group: Option<&'a str>,
24390        prefer: Option<types::CoreStatsDeletePrefer>,
24391        body: &'a types::CoreStatsDeleteRequest
24392    ) -> Result<
24393        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24394        Error<types::RcError>,
24395    > {
24396        let url = format!("{}/core/stats-delete", self.baseurl,);
24397        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24398        header_map.append(
24399            ::reqwest::header::HeaderName::from_static("api-version"),
24400            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24401        );
24402        if let Some(value) = prefer {
24403            header_map.append("Prefer", value.to_string().try_into()?);
24404        }
24405
24406        #[allow(unused_mut)]
24407        let mut request = self
24408            .client
24409            .post(url)
24410            .header(
24411                ::reqwest::header::ACCEPT,
24412                ::reqwest::header::HeaderValue::from_static("application/json"),
24413            )
24414            .json(&body)
24415            .query(&progenitor_client::QueryParam::new("_async", &async_))
24416            .query(&progenitor_client::QueryParam::new("_group", &group))
24417            .query(&progenitor_client::QueryParam::new("group", &group))
24418            .headers(header_map)
24419            .build()?;
24420        let info = OperationInfo {
24421            operation_id: "core_stats_delete",
24422        };
24423        self.pre(&mut request, &info).await?;
24424        let result = self.exec(request, &info).await;
24425        self.post(&result, &info).await?;
24426        let response = result?;
24427        match response.status().as_u16() {
24428            200u16 => ResponseValue::from_response(response).await,
24429            400u16..=499u16 => Err(Error::ErrorResponse(
24430                ResponseValue::from_response(response).await?,
24431            )),
24432            500u16..=599u16 => Err(Error::ErrorResponse(
24433                ResponseValue::from_response(response).await?,
24434            )),
24435            _ => Err(Error::UnexpectedResponse(response)),
24436        }
24437    }
24438
24439    ///Reset stats counters
24440    ///
24441    ///Clears counters, errors, and finished transfers for the provided stats
24442    /// group or all groups.
24443    ///
24444    ///Sends a `POST` request to `/core/stats-reset`
24445    ///
24446    ///Arguments:
24447    /// - `async_`: Run the command asynchronously. Returns a job id
24448    ///   immediately.
24449    /// - `group`: Assign the request to a custom stats group.
24450    /// - `group`: Stats group identifier whose counters should be reset. Leave
24451    ///   unset to reset all groups.
24452    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24453    ///   instead of 200.
24454    /// - `body`
24455    pub async fn core_stats_reset<'a>(
24456        &'a self,
24457        async_: Option<bool>,
24458        group_: Option<&'a str>,
24459        group: Option<&'a str>,
24460        prefer: Option<types::CoreStatsResetPrefer>,
24461        body: &'a types::CoreStatsResetRequest
24462    ) -> Result<
24463        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24464        Error<types::RcError>,
24465    > {
24466        let url = format!("{}/core/stats-reset", self.baseurl,);
24467        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24468        header_map.append(
24469            ::reqwest::header::HeaderName::from_static("api-version"),
24470            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24471        );
24472        if let Some(value) = prefer {
24473            header_map.append("Prefer", value.to_string().try_into()?);
24474        }
24475
24476        #[allow(unused_mut)]
24477        let mut request = self
24478            .client
24479            .post(url)
24480            .header(
24481                ::reqwest::header::ACCEPT,
24482                ::reqwest::header::HeaderValue::from_static("application/json"),
24483            )
24484            .json(&body)
24485            .query(&progenitor_client::QueryParam::new("_async", &async_))
24486            .query(&progenitor_client::QueryParam::new("_group", &group))
24487            .query(&progenitor_client::QueryParam::new("group", &group))
24488            .headers(header_map)
24489            .build()?;
24490        let info = OperationInfo {
24491            operation_id: "core_stats_reset",
24492        };
24493        self.pre(&mut request, &info).await?;
24494        let result = self.exec(request, &info).await;
24495        self.post(&result, &info).await?;
24496        let response = result?;
24497        match response.status().as_u16() {
24498            200u16 => ResponseValue::from_response(response).await,
24499            400u16..=499u16 => Err(Error::ErrorResponse(
24500                ResponseValue::from_response(response).await?,
24501            )),
24502            500u16..=599u16 => Err(Error::ErrorResponse(
24503                ResponseValue::from_response(response).await?,
24504            )),
24505            _ => Err(Error::UnexpectedResponse(response)),
24506        }
24507    }
24508
24509    ///List completed transfers
24510    ///
24511    ///Returns up to 100 recently completed transfers for the requested stats
24512    /// group.
24513    ///
24514    ///Sends a `POST` request to `/core/transferred`
24515    ///
24516    ///Arguments:
24517    /// - `async_`: Run the command asynchronously. Returns a job id
24518    ///   immediately.
24519    /// - `group`: Assign the request to a custom stats group.
24520    /// - `group`: Stats group identifier to filter the completed transfer list.
24521    ///   Leave unset for all groups.
24522    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24523    ///   instead of 200.
24524    /// - `body`
24525    pub async fn core_transferred<'a>(
24526        &'a self,
24527        async_: Option<bool>,
24528        group_: Option<&'a str>,
24529        group: Option<&'a str>,
24530        prefer: Option<types::CoreTransferredPrefer>,
24531        body: &'a types::CoreTransferredRequest
24532    ) -> Result<ResponseValue<types::CoreTransferredResponse>, Error<types::RcError>> {
24533        let url = format!("{}/core/transferred", self.baseurl,);
24534        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24535        header_map.append(
24536            ::reqwest::header::HeaderName::from_static("api-version"),
24537            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24538        );
24539        if let Some(value) = prefer {
24540            header_map.append("Prefer", value.to_string().try_into()?);
24541        }
24542
24543        #[allow(unused_mut)]
24544        let mut request = self
24545            .client
24546            .post(url)
24547            .header(
24548                ::reqwest::header::ACCEPT,
24549                ::reqwest::header::HeaderValue::from_static("application/json"),
24550            )
24551            .json(&body)
24552            .query(&progenitor_client::QueryParam::new("_async", &async_))
24553            .query(&progenitor_client::QueryParam::new("_group", &group))
24554            .query(&progenitor_client::QueryParam::new("group", &group))
24555            .headers(header_map)
24556            .build()?;
24557        let info = OperationInfo {
24558            operation_id: "core_transferred",
24559        };
24560        self.pre(&mut request, &info).await?;
24561        let result = self.exec(request, &info).await;
24562        self.post(&result, &info).await?;
24563        let response = result?;
24564        match response.status().as_u16() {
24565            200u16 => ResponseValue::from_response(response).await,
24566            400u16..=499u16 => Err(Error::ErrorResponse(
24567                ResponseValue::from_response(response).await?,
24568            )),
24569            500u16..=599u16 => Err(Error::ErrorResponse(
24570                ResponseValue::from_response(response).await?,
24571            )),
24572            _ => Err(Error::UnexpectedResponse(response)),
24573        }
24574    }
24575
24576    ///Sends a `POST` request to `/debug/set-block-profile-rate`
24577    ///
24578    ///Arguments:
24579    /// - `async_`: Run the command asynchronously. Returns a job id
24580    ///   immediately.
24581    /// - `group`: Assign the request to a custom stats group.
24582    /// - `rate`: Sampling interval in nanoseconds for blocking profile
24583    ///   collection; use 1 to capture all events.
24584    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24585    ///   instead of 200.
24586    /// - `body`
24587    pub async fn debug_set_block_profile_rate<'a>(
24588        &'a self,
24589        async_: Option<bool>,
24590        group: Option<&'a str>,
24591        rate: Option<i64>,
24592        prefer: Option<types::DebugSetBlockProfileRatePrefer>,
24593        body: &'a types::DebugSetBlockProfileRateRequest,
24594    ) -> Result<
24595        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24596        Error<types::RcError>,
24597    > {
24598        let url = format!("{}/debug/set-block-profile-rate", self.baseurl,);
24599        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24600        header_map.append(
24601            ::reqwest::header::HeaderName::from_static("api-version"),
24602            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24603        );
24604        if let Some(value) = prefer {
24605            header_map.append("Prefer", value.to_string().try_into()?);
24606        }
24607
24608        #[allow(unused_mut)]
24609        let mut request = self
24610            .client
24611            .post(url)
24612            .header(
24613                ::reqwest::header::ACCEPT,
24614                ::reqwest::header::HeaderValue::from_static("application/json"),
24615            )
24616            .json(&body)
24617            .query(&progenitor_client::QueryParam::new("_async", &async_))
24618            .query(&progenitor_client::QueryParam::new("_group", &group))
24619            .query(&progenitor_client::QueryParam::new("rate", &rate))
24620            .headers(header_map)
24621            .build()?;
24622        let info = OperationInfo {
24623            operation_id: "debug_set_block_profile_rate",
24624        };
24625        self.pre(&mut request, &info).await?;
24626        let result = self.exec(request, &info).await;
24627        self.post(&result, &info).await?;
24628        let response = result?;
24629        match response.status().as_u16() {
24630            200u16 => ResponseValue::from_response(response).await,
24631            400u16..=499u16 => Err(Error::ErrorResponse(
24632                ResponseValue::from_response(response).await?,
24633            )),
24634            500u16..=599u16 => Err(Error::ErrorResponse(
24635                ResponseValue::from_response(response).await?,
24636            )),
24637            _ => Err(Error::UnexpectedResponse(response)),
24638        }
24639    }
24640
24641    ///Sends a `POST` request to `/debug/set-gc-percent`
24642    ///
24643    ///Arguments:
24644    /// - `async_`: Run the command asynchronously. Returns a job id
24645    ///   immediately.
24646    /// - `group`: Assign the request to a custom stats group.
24647    /// - `gc_percent`: Target percentage of newly allocated data to trigger
24648    ///   garbage collection.
24649    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24650    ///   instead of 200.
24651    /// - `body`
24652    pub async fn debug_set_gc_percent<'a>(
24653        &'a self,
24654        async_: Option<bool>,
24655        group: Option<&'a str>,
24656        gc_percent: Option<i64>,
24657        prefer: Option<types::DebugSetGcPercentPrefer>,
24658        body: &'a types::DebugSetGcPercentRequest,
24659    ) -> Result<ResponseValue<types::DebugSetGcPercentResponse>, Error<types::RcError>> {
24660        let url = format!("{}/debug/set-gc-percent", self.baseurl,);
24661        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24662        header_map.append(
24663            ::reqwest::header::HeaderName::from_static("api-version"),
24664            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24665        );
24666        if let Some(value) = prefer {
24667            header_map.append("Prefer", value.to_string().try_into()?);
24668        }
24669
24670        #[allow(unused_mut)]
24671        let mut request = self
24672            .client
24673            .post(url)
24674            .header(
24675                ::reqwest::header::ACCEPT,
24676                ::reqwest::header::HeaderValue::from_static("application/json"),
24677            )
24678            .json(&body)
24679            .query(&progenitor_client::QueryParam::new("_async", &async_))
24680            .query(&progenitor_client::QueryParam::new("_group", &group))
24681            .query(&progenitor_client::QueryParam::new(
24682                "gc-percent",
24683                &gc_percent,
24684            ))
24685            .headers(header_map)
24686            .build()?;
24687        let info = OperationInfo {
24688            operation_id: "debug_set_gc_percent",
24689        };
24690        self.pre(&mut request, &info).await?;
24691        let result = self.exec(request, &info).await;
24692        self.post(&result, &info).await?;
24693        let response = result?;
24694        match response.status().as_u16() {
24695            200u16 => ResponseValue::from_response(response).await,
24696            400u16..=499u16 => Err(Error::ErrorResponse(
24697                ResponseValue::from_response(response).await?,
24698            )),
24699            500u16..=599u16 => Err(Error::ErrorResponse(
24700                ResponseValue::from_response(response).await?,
24701            )),
24702            _ => Err(Error::UnexpectedResponse(response)),
24703        }
24704    }
24705
24706    ///Sends a `POST` request to `/debug/set-mutex-profile-fraction`
24707    ///
24708    ///Arguments:
24709    /// - `async_`: Run the command asynchronously. Returns a job id
24710    ///   immediately.
24711    /// - `group`: Assign the request to a custom stats group.
24712    /// - `rate`: Sampling fraction for mutex contention profiling; set to 0 to
24713    ///   disable.
24714    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24715    ///   instead of 200.
24716    /// - `body`
24717    pub async fn debug_set_mutex_profile_fraction<'a>(
24718        &'a self,
24719        async_: Option<bool>,
24720        group: Option<&'a str>,
24721        rate: Option<i64>,
24722        prefer: Option<types::DebugSetMutexProfileFractionPrefer>,
24723        body: &'a types::DebugSetMutexProfileFractionRequest,
24724    ) -> Result<ResponseValue<types::DebugSetMutexProfileFractionResponse>, Error<types::RcError>>
24725    {
24726        let url = format!("{}/debug/set-mutex-profile-fraction", self.baseurl,);
24727        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24728        header_map.append(
24729            ::reqwest::header::HeaderName::from_static("api-version"),
24730            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24731        );
24732        if let Some(value) = prefer {
24733            header_map.append("Prefer", value.to_string().try_into()?);
24734        }
24735
24736        #[allow(unused_mut)]
24737        let mut request = self
24738            .client
24739            .post(url)
24740            .header(
24741                ::reqwest::header::ACCEPT,
24742                ::reqwest::header::HeaderValue::from_static("application/json"),
24743            )
24744            .json(&body)
24745            .query(&progenitor_client::QueryParam::new("_async", &async_))
24746            .query(&progenitor_client::QueryParam::new("_group", &group))
24747            .query(&progenitor_client::QueryParam::new("rate", &rate))
24748            .headers(header_map)
24749            .build()?;
24750        let info = OperationInfo {
24751            operation_id: "debug_set_mutex_profile_fraction",
24752        };
24753        self.pre(&mut request, &info).await?;
24754        let result = self.exec(request, &info).await;
24755        self.post(&result, &info).await?;
24756        let response = result?;
24757        match response.status().as_u16() {
24758            200u16 => ResponseValue::from_response(response).await,
24759            400u16..=499u16 => Err(Error::ErrorResponse(
24760                ResponseValue::from_response(response).await?,
24761            )),
24762            500u16..=599u16 => Err(Error::ErrorResponse(
24763                ResponseValue::from_response(response).await?,
24764            )),
24765            _ => Err(Error::UnexpectedResponse(response)),
24766        }
24767    }
24768
24769    ///Sends a `POST` request to `/debug/set-soft-memory-limit`
24770    ///
24771    ///Arguments:
24772    /// - `async_`: Run the command asynchronously. Returns a job id
24773    ///   immediately.
24774    /// - `group`: Assign the request to a custom stats group.
24775    /// - `mem_limit`: Soft memory limit for the Go runtime in bytes.
24776    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24777    ///   instead of 200.
24778    /// - `body`
24779    pub async fn debug_set_soft_memory_limit<'a>(
24780        &'a self,
24781        async_: Option<bool>,
24782        group: Option<&'a str>,
24783        mem_limit: Option<i64>,
24784        prefer: Option<types::DebugSetSoftMemoryLimitPrefer>,
24785        body: &'a types::DebugSetSoftMemoryLimitRequest,
24786    ) -> Result<ResponseValue<types::DebugSetSoftMemoryLimitResponse>, Error<types::RcError>> {
24787        let url = format!("{}/debug/set-soft-memory-limit", self.baseurl,);
24788        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24789        header_map.append(
24790            ::reqwest::header::HeaderName::from_static("api-version"),
24791            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24792        );
24793        if let Some(value) = prefer {
24794            header_map.append("Prefer", value.to_string().try_into()?);
24795        }
24796
24797        #[allow(unused_mut)]
24798        let mut request = self
24799            .client
24800            .post(url)
24801            .header(
24802                ::reqwest::header::ACCEPT,
24803                ::reqwest::header::HeaderValue::from_static("application/json"),
24804            )
24805            .json(&body)
24806            .query(&progenitor_client::QueryParam::new("_async", &async_))
24807            .query(&progenitor_client::QueryParam::new("_group", &group))
24808            .query(&progenitor_client::QueryParam::new("mem-limit", &mem_limit))
24809            .headers(header_map)
24810            .build()?;
24811        let info = OperationInfo {
24812            operation_id: "debug_set_soft_memory_limit",
24813        };
24814        self.pre(&mut request, &info).await?;
24815        let result = self.exec(request, &info).await;
24816        self.post(&result, &info).await?;
24817        let response = result?;
24818        match response.status().as_u16() {
24819            200u16 => ResponseValue::from_response(response).await,
24820            400u16..=499u16 => Err(Error::ErrorResponse(
24821                ResponseValue::from_response(response).await?,
24822            )),
24823            500u16..=599u16 => Err(Error::ErrorResponse(
24824                ResponseValue::from_response(response).await?,
24825            )),
24826            _ => Err(Error::UnexpectedResponse(response)),
24827        }
24828    }
24829
24830    ///Sends a `POST` request to `/fscache/clear`
24831    ///
24832    ///Arguments:
24833    /// - `async_`: Run the command asynchronously. Returns a job id
24834    ///   immediately.
24835    /// - `group`: Assign the request to a custom stats group.
24836    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24837    ///   instead of 200.
24838    /// - `body`
24839    pub async fn fscache_clear<'a>(
24840        &'a self,
24841        async_: Option<bool>,
24842        group: Option<&'a str>,
24843        prefer: Option<types::FscacheClearPrefer>,
24844        body: &'a types::FscacheClearRequest,
24845    ) -> Result<
24846        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
24847        Error<types::RcError>,
24848    > {
24849        let url = format!("{}/fscache/clear", self.baseurl,);
24850        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24851        header_map.append(
24852            ::reqwest::header::HeaderName::from_static("api-version"),
24853            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24854        );
24855        if let Some(value) = prefer {
24856            header_map.append("Prefer", value.to_string().try_into()?);
24857        }
24858
24859        #[allow(unused_mut)]
24860        let mut request = self
24861            .client
24862            .post(url)
24863            .header(
24864                ::reqwest::header::ACCEPT,
24865                ::reqwest::header::HeaderValue::from_static("application/json"),
24866            )
24867            .json(&body)
24868            .query(&progenitor_client::QueryParam::new("_async", &async_))
24869            .query(&progenitor_client::QueryParam::new("_group", &group))
24870            .headers(header_map)
24871            .build()?;
24872        let info = OperationInfo {
24873            operation_id: "fscache_clear",
24874        };
24875        self.pre(&mut request, &info).await?;
24876        let result = self.exec(request, &info).await;
24877        self.post(&result, &info).await?;
24878        let response = result?;
24879        match response.status().as_u16() {
24880            200u16 => ResponseValue::from_response(response).await,
24881            400u16..=499u16 => Err(Error::ErrorResponse(
24882                ResponseValue::from_response(response).await?,
24883            )),
24884            500u16..=599u16 => Err(Error::ErrorResponse(
24885                ResponseValue::from_response(response).await?,
24886            )),
24887            _ => Err(Error::UnexpectedResponse(response)),
24888        }
24889    }
24890
24891    ///Sends a `POST` request to `/fscache/entries`
24892    ///
24893    ///Arguments:
24894    /// - `async_`: Run the command asynchronously. Returns a job id
24895    ///   immediately.
24896    /// - `group`: Assign the request to a custom stats group.
24897    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24898    ///   instead of 200.
24899    /// - `body`
24900    pub async fn fscache_entries<'a>(
24901        &'a self,
24902        async_: Option<bool>,
24903        group: Option<&'a str>,
24904        prefer: Option<types::FscacheEntriesPrefer>,
24905        body: &'a types::FscacheEntriesRequest,
24906    ) -> Result<ResponseValue<types::FscacheEntriesResponse>, Error<types::RcError>> {
24907        let url = format!("{}/fscache/entries", self.baseurl,);
24908        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24909        header_map.append(
24910            ::reqwest::header::HeaderName::from_static("api-version"),
24911            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24912        );
24913        if let Some(value) = prefer {
24914            header_map.append("Prefer", value.to_string().try_into()?);
24915        }
24916
24917        #[allow(unused_mut)]
24918        let mut request = self
24919            .client
24920            .post(url)
24921            .header(
24922                ::reqwest::header::ACCEPT,
24923                ::reqwest::header::HeaderValue::from_static("application/json"),
24924            )
24925            .json(&body)
24926            .query(&progenitor_client::QueryParam::new("_async", &async_))
24927            .query(&progenitor_client::QueryParam::new("_group", &group))
24928            .headers(header_map)
24929            .build()?;
24930        let info = OperationInfo {
24931            operation_id: "fscache_entries",
24932        };
24933        self.pre(&mut request, &info).await?;
24934        let result = self.exec(request, &info).await;
24935        self.post(&result, &info).await?;
24936        let response = result?;
24937        match response.status().as_u16() {
24938            200u16 => ResponseValue::from_response(response).await,
24939            400u16..=499u16 => Err(Error::ErrorResponse(
24940                ResponseValue::from_response(response).await?,
24941            )),
24942            500u16..=599u16 => Err(Error::ErrorResponse(
24943                ResponseValue::from_response(response).await?,
24944            )),
24945            _ => Err(Error::UnexpectedResponse(response)),
24946        }
24947    }
24948
24949    ///Sends a `POST` request to `/mount/listmounts`
24950    ///
24951    ///Arguments:
24952    /// - `async_`: Run the command asynchronously. Returns a job id
24953    ///   immediately.
24954    /// - `group`: Assign the request to a custom stats group.
24955    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
24956    ///   instead of 200.
24957    /// - `body`
24958    pub async fn mount_listmounts<'a>(
24959        &'a self,
24960        async_: Option<bool>,
24961        group: Option<&'a str>,
24962        prefer: Option<types::MountListmountsPrefer>,
24963        body: &'a types::MountListmountsRequest,
24964    ) -> Result<ResponseValue<types::MountListmountsResponse>, Error<types::RcError>> {
24965        let url = format!("{}/mount/listmounts", self.baseurl,);
24966        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
24967        header_map.append(
24968            ::reqwest::header::HeaderName::from_static("api-version"),
24969            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
24970        );
24971        if let Some(value) = prefer {
24972            header_map.append("Prefer", value.to_string().try_into()?);
24973        }
24974
24975        #[allow(unused_mut)]
24976        let mut request = self
24977            .client
24978            .post(url)
24979            .header(
24980                ::reqwest::header::ACCEPT,
24981                ::reqwest::header::HeaderValue::from_static("application/json"),
24982            )
24983            .json(&body)
24984            .query(&progenitor_client::QueryParam::new("_async", &async_))
24985            .query(&progenitor_client::QueryParam::new("_group", &group))
24986            .headers(header_map)
24987            .build()?;
24988        let info = OperationInfo {
24989            operation_id: "mount_listmounts",
24990        };
24991        self.pre(&mut request, &info).await?;
24992        let result = self.exec(request, &info).await;
24993        self.post(&result, &info).await?;
24994        let response = result?;
24995        match response.status().as_u16() {
24996            200u16 => ResponseValue::from_response(response).await,
24997            400u16..=499u16 => Err(Error::ErrorResponse(
24998                ResponseValue::from_response(response).await?,
24999            )),
25000            500u16..=599u16 => Err(Error::ErrorResponse(
25001                ResponseValue::from_response(response).await?,
25002            )),
25003            _ => Err(Error::UnexpectedResponse(response)),
25004        }
25005    }
25006
25007    ///Sends a `POST` request to `/mount/mount`
25008    ///
25009    ///Arguments:
25010    /// - `async_`: Run the command asynchronously. Returns a job id
25011    ///   immediately.
25012    /// - `config`: JSON encoded config overrides applied for this call only.
25013    /// - `filter`: JSON encoded filter overrides applied for this call only.
25014    /// - `group`: Assign the request to a custom stats group.
25015    /// - `fs`: Remote path to mount, such as `drive:` or `remote:subdir`.
25016    /// - `mount_opt`: Mount options encoded as JSON, matching flags accepted by
25017    ///   `rclone mount`.
25018    /// - `mount_point`: Absolute local path where the remote should be mounted.
25019    /// - `mount_type`: Optional mount implementation to use (`mount`, `cmount`,
25020    ///   or `mount2`).
25021    /// - `vfs_opt`: VFS options encoded as JSON, matching flags accepted by
25022    ///   `rclone mount`.
25023    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25024    ///   instead of 200.
25025    /// - `body`
25026    pub async fn mount_mount<'a>(
25027        &'a self,
25028        async_: Option<bool>,
25029        config: Option<&'a str>,
25030        filter: Option<&'a str>,
25031        group: Option<&'a str>,
25032        fs: Option<&'a str>,
25033        mount_opt: Option<&'a str>,
25034        mount_point: Option<&'a str>,
25035        mount_type: Option<&'a str>,
25036        vfs_opt: Option<&'a str>,
25037        prefer: Option<types::MountMountPrefer>,
25038        body: &'a types::MountMountRequest,
25039    ) -> Result<ResponseValue<types::MountMountResponse>, Error<types::RcError>> {
25040        let url = format!("{}/mount/mount", self.baseurl,);
25041        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25042        header_map.append(
25043            ::reqwest::header::HeaderName::from_static("api-version"),
25044            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25045        );
25046        if let Some(value) = prefer {
25047            header_map.append("Prefer", value.to_string().try_into()?);
25048        }
25049
25050        #[allow(unused_mut)]
25051        let mut request = self
25052            .client
25053            .post(url)
25054            .header(
25055                ::reqwest::header::ACCEPT,
25056                ::reqwest::header::HeaderValue::from_static("application/json"),
25057            )
25058            .json(&body)
25059            .query(&progenitor_client::QueryParam::new("_async", &async_))
25060            .query(&progenitor_client::QueryParam::new("_config", &config))
25061            .query(&progenitor_client::QueryParam::new("_filter", &filter))
25062            .query(&progenitor_client::QueryParam::new("_group", &group))
25063            .query(&progenitor_client::QueryParam::new("fs", &fs))
25064            .query(&progenitor_client::QueryParam::new("mountOpt", &mount_opt))
25065            .query(&progenitor_client::QueryParam::new(
25066                "mountPoint",
25067                &mount_point,
25068            ))
25069            .query(&progenitor_client::QueryParam::new(
25070                "mountType",
25071                &mount_type,
25072            ))
25073            .query(&progenitor_client::QueryParam::new("vfsOpt", &vfs_opt))
25074            .headers(header_map)
25075            .build()?;
25076        let info = OperationInfo {
25077            operation_id: "mount_mount",
25078        };
25079        self.pre(&mut request, &info).await?;
25080        let result = self.exec(request, &info).await;
25081        self.post(&result, &info).await?;
25082        let response = result?;
25083        match response.status().as_u16() {
25084            200u16 => ResponseValue::from_response(response).await,
25085            400u16..=499u16 => Err(Error::ErrorResponse(
25086                ResponseValue::from_response(response).await?,
25087            )),
25088            500u16..=599u16 => Err(Error::ErrorResponse(
25089                ResponseValue::from_response(response).await?,
25090            )),
25091            _ => Err(Error::UnexpectedResponse(response)),
25092        }
25093    }
25094
25095    ///Sends a `POST` request to `/mount/types`
25096    ///
25097    ///Arguments:
25098    /// - `async_`: Run the command asynchronously. Returns a job id
25099    ///   immediately.
25100    /// - `group`: Assign the request to a custom stats group.
25101    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25102    ///   instead of 200.
25103    /// - `body`
25104    pub async fn mount_types<'a>(
25105        &'a self,
25106        async_: Option<bool>,
25107        group: Option<&'a str>,
25108        prefer: Option<types::MountTypesPrefer>,
25109        body: &'a types::MountTypesRequest,
25110    ) -> Result<ResponseValue<types::MountTypesResponse>, Error<types::RcError>> {
25111        let url = format!("{}/mount/types", self.baseurl,);
25112        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25113        header_map.append(
25114            ::reqwest::header::HeaderName::from_static("api-version"),
25115            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25116        );
25117        if let Some(value) = prefer {
25118            header_map.append("Prefer", value.to_string().try_into()?);
25119        }
25120
25121        #[allow(unused_mut)]
25122        let mut request = self
25123            .client
25124            .post(url)
25125            .header(
25126                ::reqwest::header::ACCEPT,
25127                ::reqwest::header::HeaderValue::from_static("application/json"),
25128            )
25129            .json(&body)
25130            .query(&progenitor_client::QueryParam::new("_async", &async_))
25131            .query(&progenitor_client::QueryParam::new("_group", &group))
25132            .headers(header_map)
25133            .build()?;
25134        let info = OperationInfo {
25135            operation_id: "mount_types",
25136        };
25137        self.pre(&mut request, &info).await?;
25138        let result = self.exec(request, &info).await;
25139        self.post(&result, &info).await?;
25140        let response = result?;
25141        match response.status().as_u16() {
25142            200u16 => ResponseValue::from_response(response).await,
25143            400u16..=499u16 => Err(Error::ErrorResponse(
25144                ResponseValue::from_response(response).await?,
25145            )),
25146            500u16..=599u16 => Err(Error::ErrorResponse(
25147                ResponseValue::from_response(response).await?,
25148            )),
25149            _ => Err(Error::UnexpectedResponse(response)),
25150        }
25151    }
25152
25153    ///Sends a `POST` request to `/mount/unmount`
25154    ///
25155    ///Arguments:
25156    /// - `async_`: Run the command asynchronously. Returns a job id
25157    ///   immediately.
25158    /// - `group`: Assign the request to a custom stats group.
25159    /// - `mount_point`: Local mount point path to unmount.
25160    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25161    ///   instead of 200.
25162    /// - `body`
25163    pub async fn mount_unmount<'a>(
25164        &'a self,
25165        async_: Option<bool>,
25166        group: Option<&'a str>,
25167        mount_point: Option<&'a str>,
25168        prefer: Option<types::MountUnmountPrefer>,
25169        body: &'a types::MountUnmountRequest,
25170    ) -> Result<
25171        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25172        Error<types::RcError>,
25173    > {
25174        let url = format!("{}/mount/unmount", self.baseurl,);
25175        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25176        header_map.append(
25177            ::reqwest::header::HeaderName::from_static("api-version"),
25178            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25179        );
25180        if let Some(value) = prefer {
25181            header_map.append("Prefer", value.to_string().try_into()?);
25182        }
25183
25184        #[allow(unused_mut)]
25185        let mut request = self
25186            .client
25187            .post(url)
25188            .header(
25189                ::reqwest::header::ACCEPT,
25190                ::reqwest::header::HeaderValue::from_static("application/json"),
25191            )
25192            .json(&body)
25193            .query(&progenitor_client::QueryParam::new("_async", &async_))
25194            .query(&progenitor_client::QueryParam::new("_group", &group))
25195            .query(&progenitor_client::QueryParam::new(
25196                "mountPoint",
25197                &mount_point,
25198            ))
25199            .headers(header_map)
25200            .build()?;
25201        let info = OperationInfo {
25202            operation_id: "mount_unmount",
25203        };
25204        self.pre(&mut request, &info).await?;
25205        let result = self.exec(request, &info).await;
25206        self.post(&result, &info).await?;
25207        let response = result?;
25208        match response.status().as_u16() {
25209            200u16 => ResponseValue::from_response(response).await,
25210            400u16..=499u16 => Err(Error::ErrorResponse(
25211                ResponseValue::from_response(response).await?,
25212            )),
25213            500u16..=599u16 => Err(Error::ErrorResponse(
25214                ResponseValue::from_response(response).await?,
25215            )),
25216            _ => Err(Error::UnexpectedResponse(response)),
25217        }
25218    }
25219
25220    ///Sends a `POST` request to `/mount/unmountall`
25221    ///
25222    ///Arguments:
25223    /// - `async_`: Run the command asynchronously. Returns a job id
25224    ///   immediately.
25225    /// - `group`: Assign the request to a custom stats group.
25226    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25227    ///   instead of 200.
25228    /// - `body`
25229    pub async fn mount_unmountall<'a>(
25230        &'a self,
25231        async_: Option<bool>,
25232        group: Option<&'a str>,
25233        prefer: Option<types::MountUnmountallPrefer>,
25234        body: &'a types::MountUnmountallRequest,
25235    ) -> Result<
25236        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25237        Error<types::RcError>,
25238    > {
25239        let url = format!("{}/mount/unmountall", self.baseurl,);
25240        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25241        header_map.append(
25242            ::reqwest::header::HeaderName::from_static("api-version"),
25243            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25244        );
25245        if let Some(value) = prefer {
25246            header_map.append("Prefer", value.to_string().try_into()?);
25247        }
25248
25249        #[allow(unused_mut)]
25250        let mut request = self
25251            .client
25252            .post(url)
25253            .header(
25254                ::reqwest::header::ACCEPT,
25255                ::reqwest::header::HeaderValue::from_static("application/json"),
25256            )
25257            .json(&body)
25258            .query(&progenitor_client::QueryParam::new("_async", &async_))
25259            .query(&progenitor_client::QueryParam::new("_group", &group))
25260            .headers(header_map)
25261            .build()?;
25262        let info = OperationInfo {
25263            operation_id: "mount_unmountall",
25264        };
25265        self.pre(&mut request, &info).await?;
25266        let result = self.exec(request, &info).await;
25267        self.post(&result, &info).await?;
25268        let response = result?;
25269        match response.status().as_u16() {
25270            200u16 => ResponseValue::from_response(response).await,
25271            400u16..=499u16 => Err(Error::ErrorResponse(
25272                ResponseValue::from_response(response).await?,
25273            )),
25274            500u16..=599u16 => Err(Error::ErrorResponse(
25275                ResponseValue::from_response(response).await?,
25276            )),
25277            _ => Err(Error::UnexpectedResponse(response)),
25278        }
25279    }
25280
25281    ///Echo parameters (auth required)
25282    ///
25283    ///Same as `rc/noop`, but requires authentication to validate access
25284    /// control.
25285    ///
25286    ///Sends a `POST` request to `/rc/noopauth`
25287    ///
25288    ///Arguments:
25289    /// - `async_`: Run the command asynchronously. Returns a job id
25290    ///   immediately.
25291    /// - `params`: Additional arbitrary parameters allowed.
25292    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25293    ///   instead of 200.
25294    /// - `body`
25295    pub async fn rc_noop_auth<'a>(
25296        &'a self,
25297        async_: Option<bool>,
25298        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25299        prefer: Option<types::RcNoopAuthPrefer>,
25300        body: &'a types::RcNoopAuthRequest,
25301    ) -> Result<
25302        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25303        Error<types::RcError>,
25304    > {
25305        let url = format!("{}/rc/noopauth", self.baseurl,);
25306        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25307        header_map.append(
25308            ::reqwest::header::HeaderName::from_static("api-version"),
25309            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25310        );
25311        if let Some(value) = prefer {
25312            header_map.append("Prefer", value.to_string().try_into()?);
25313        }
25314
25315        #[allow(unused_mut)]
25316        let mut request = self
25317            .client
25318            .post(url)
25319            .header(
25320                ::reqwest::header::ACCEPT,
25321                ::reqwest::header::HeaderValue::from_static("application/json"),
25322            )
25323            .json(&body)
25324            .query(&progenitor_client::QueryParam::new("_async", &async_))
25325            .query(&progenitor_client::QueryParam::new("params", &params))
25326            .headers(header_map)
25327            .build()?;
25328        let info = OperationInfo {
25329            operation_id: "rc_noop_auth",
25330        };
25331        self.pre(&mut request, &info).await?;
25332        let result = self.exec(request, &info).await;
25333        self.post(&result, &info).await?;
25334        let response = result?;
25335        match response.status().as_u16() {
25336            200u16 => ResponseValue::from_response(response).await,
25337            400u16..=499u16 => Err(Error::ErrorResponse(
25338                ResponseValue::from_response(response).await?,
25339            )),
25340            500u16..=599u16 => Err(Error::ErrorResponse(
25341                ResponseValue::from_response(response).await?,
25342            )),
25343            _ => Err(Error::UnexpectedResponse(response)),
25344        }
25345    }
25346
25347    ///Return a test error
25348    ///
25349    ///Always returns an error response incorporating the supplied parameters,
25350    /// useful for testing error handling.
25351    ///
25352    ///Sends a `POST` request to `/rc/error`
25353    ///
25354    ///Arguments:
25355    /// - `async_`: Run the command asynchronously. Returns a job id
25356    ///   immediately.
25357    /// - `params`: Additional arbitrary parameters allowed.
25358    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25359    ///   instead of 200.
25360    /// - `body`
25361    pub async fn rc_error<'a>(
25362        &'a self,
25363        async_: Option<bool>,
25364        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25365        prefer: Option<types::RcErrorPrefer>,
25366        body: &'a types::RcErrorRequest,
25367    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
25368        let url = format!("{}/rc/error", self.baseurl,);
25369        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25370        header_map.append(
25371            ::reqwest::header::HeaderName::from_static("api-version"),
25372            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25373        );
25374        if let Some(value) = prefer {
25375            header_map.append("Prefer", value.to_string().try_into()?);
25376        }
25377
25378        #[allow(unused_mut)]
25379        let mut request = self
25380            .client
25381            .post(url)
25382            .header(
25383                ::reqwest::header::ACCEPT,
25384                ::reqwest::header::HeaderValue::from_static("application/json"),
25385            )
25386            .json(&body)
25387            .query(&progenitor_client::QueryParam::new("_async", &async_))
25388            .query(&progenitor_client::QueryParam::new("params", &params))
25389            .headers(header_map)
25390            .build()?;
25391        let info = OperationInfo {
25392            operation_id: "rc_error",
25393        };
25394        self.pre(&mut request, &info).await?;
25395        let result = self.exec(request, &info).await;
25396        self.post(&result, &info).await?;
25397        let response = result?;
25398        match response.status().as_u16() {
25399            200u16 => Ok(ResponseValue::empty(response)),
25400            400u16..=499u16 => Err(Error::ErrorResponse(
25401                ResponseValue::from_response(response).await?,
25402            )),
25403            500u16..=599u16 => Err(Error::ErrorResponse(
25404                ResponseValue::from_response(response).await?,
25405            )),
25406            _ => Err(Error::UnexpectedResponse(response)),
25407        }
25408    }
25409
25410    ///List RC commands
25411    ///
25412    ///Returns metadata about every available RC command, including whether
25413    /// authentication is required.
25414    ///
25415    ///Sends a `POST` request to `/rc/list`
25416    ///
25417    ///Arguments:
25418    /// - `async_`: Run the command asynchronously. Returns a job id
25419    ///   immediately.
25420    /// - `group`: Assign the request to a custom stats group.
25421    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25422    ///   instead of 200.
25423    /// - `body`
25424    pub async fn rc_list<'a>(
25425        &'a self,
25426        async_: Option<bool>,
25427        group: Option<&'a str>,
25428        prefer: Option<types::RcListPrefer>,
25429        body: &'a types::RcListRequest,
25430    ) -> Result<ResponseValue<types::RcListResponse>, Error<types::RcError>> {
25431        let url = format!("{}/rc/list", self.baseurl,);
25432        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25433        header_map.append(
25434            ::reqwest::header::HeaderName::from_static("api-version"),
25435            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25436        );
25437        if let Some(value) = prefer {
25438            header_map.append("Prefer", value.to_string().try_into()?);
25439        }
25440
25441        #[allow(unused_mut)]
25442        let mut request = self
25443            .client
25444            .post(url)
25445            .header(
25446                ::reqwest::header::ACCEPT,
25447                ::reqwest::header::HeaderValue::from_static("application/json"),
25448            )
25449            .json(&body)
25450            .query(&progenitor_client::QueryParam::new("_async", &async_))
25451            .query(&progenitor_client::QueryParam::new("_group", &group))
25452            .headers(header_map)
25453            .build()?;
25454        let info = OperationInfo {
25455            operation_id: "rc_list",
25456        };
25457        self.pre(&mut request, &info).await?;
25458        let result = self.exec(request, &info).await;
25459        self.post(&result, &info).await?;
25460        let response = result?;
25461        match response.status().as_u16() {
25462            200u16 => ResponseValue::from_response(response).await,
25463            400u16..=499u16 => Err(Error::ErrorResponse(
25464                ResponseValue::from_response(response).await?,
25465            )),
25466            500u16..=599u16 => Err(Error::ErrorResponse(
25467                ResponseValue::from_response(response).await?,
25468            )),
25469            _ => Err(Error::UnexpectedResponse(response)),
25470        }
25471    }
25472
25473    ///Run backend command
25474    ///
25475    ///Invokes a backend-specific management command against an optional
25476    /// remote.
25477    ///
25478    ///Sends a `POST` request to `/backend/command`
25479    ///
25480    ///Arguments:
25481    /// - `async_`: Run the command asynchronously. Returns a job id
25482    ///   immediately.
25483    /// - `group`: Assign the request to a custom stats group.
25484    /// - `arg`: Optional positional arguments for the backend command.
25485    /// - `command`: Backend-specific command to invoke.
25486    /// - `fs`: Remote name or path the backend command should target.
25487    /// - `opt`: Backend command options encoded as a JSON string.
25488    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25489    ///   instead of 200.
25490    /// - `body`
25491    pub async fn backend_command<'a>(
25492        &'a self,
25493        async_: Option<bool>,
25494        group: Option<&'a str>,
25495        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
25496        command: Option<&'a str>,
25497        fs: Option<&'a str>,
25498        opt: Option<&'a str>,
25499        prefer: Option<types::BackendCommandPrefer>,
25500        body: &'a types::BackendCommandRequest,
25501    ) -> Result<ResponseValue<types::BackendCommandResponse>, Error<types::RcError>> {
25502        let url = format!("{}/backend/command", self.baseurl,);
25503        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25504        header_map.append(
25505            ::reqwest::header::HeaderName::from_static("api-version"),
25506            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25507        );
25508        if let Some(value) = prefer {
25509            header_map.append("Prefer", value.to_string().try_into()?);
25510        }
25511
25512        #[allow(unused_mut)]
25513        let mut request = self
25514            .client
25515            .post(url)
25516            .header(
25517                ::reqwest::header::ACCEPT,
25518                ::reqwest::header::HeaderValue::from_static("application/json"),
25519            )
25520            .json(&body)
25521            .query(&progenitor_client::QueryParam::new("_async", &async_))
25522            .query(&progenitor_client::QueryParam::new("_group", &group))
25523            .query(&progenitor_client::QueryParam::new("arg", &arg))
25524            .query(&progenitor_client::QueryParam::new("command", &command))
25525            .query(&progenitor_client::QueryParam::new("fs", &fs))
25526            .query(&progenitor_client::QueryParam::new("opt", &opt))
25527            .headers(header_map)
25528            .build()?;
25529        let info = OperationInfo {
25530            operation_id: "backend_command",
25531        };
25532        self.pre(&mut request, &info).await?;
25533        let result = self.exec(request, &info).await;
25534        self.post(&result, &info).await?;
25535        let response = result?;
25536        match response.status().as_u16() {
25537            200u16 => ResponseValue::from_response(response).await,
25538            400u16..=499u16 => Err(Error::ErrorResponse(
25539                ResponseValue::from_response(response).await?,
25540            )),
25541            500u16..=599u16 => Err(Error::ErrorResponse(
25542                ResponseValue::from_response(response).await?,
25543            )),
25544            _ => Err(Error::UnexpectedResponse(response)),
25545        }
25546    }
25547
25548    ///Expire cache entries
25549    ///
25550    ///Drops cached directory entries, and optionally cached file data, for the
25551    /// cache backend.
25552    ///
25553    ///Sends a `POST` request to `/cache/expire`
25554    ///
25555    ///Arguments:
25556    /// - `async_`: Run the command asynchronously. Returns a job id
25557    ///   immediately.
25558    /// - `group`: Assign the request to a custom stats group.
25559    /// - `remote`: Remote path to expire from the cache, e.g.
25560    ///   `remote:path/to/dir`.
25561    /// - `with_data`: Set to true to drop cached chunk data along with
25562    ///   directory entries.
25563    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25564    ///   instead of 200.
25565    /// - `body`
25566    pub async fn cache_expire<'a>(
25567        &'a self,
25568        async_: Option<bool>,
25569        group: Option<&'a str>,
25570        remote: Option<&'a str>,
25571        with_data: Option<bool>,
25572        prefer: Option<types::CacheExpirePrefer>,
25573        body: &'a types::CacheExpireRequest,
25574    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
25575        let url = format!("{}/cache/expire", self.baseurl,);
25576        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25577        header_map.append(
25578            ::reqwest::header::HeaderName::from_static("api-version"),
25579            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25580        );
25581        if let Some(value) = prefer {
25582            header_map.append("Prefer", value.to_string().try_into()?);
25583        }
25584
25585        #[allow(unused_mut)]
25586        let mut request = self
25587            .client
25588            .post(url)
25589            .header(
25590                ::reqwest::header::ACCEPT,
25591                ::reqwest::header::HeaderValue::from_static("application/json"),
25592            )
25593            .json(&body)
25594            .query(&progenitor_client::QueryParam::new("_async", &async_))
25595            .query(&progenitor_client::QueryParam::new("_group", &group))
25596            .query(&progenitor_client::QueryParam::new("remote", &remote))
25597            .query(&progenitor_client::QueryParam::new("withData", &with_data))
25598            .headers(header_map)
25599            .build()?;
25600        let info = OperationInfo {
25601            operation_id: "cache_expire",
25602        };
25603        self.pre(&mut request, &info).await?;
25604        let result = self.exec(request, &info).await;
25605        self.post(&result, &info).await?;
25606        let response = result?;
25607        match response.status().as_u16() {
25608            200u16 => Ok(ResponseValue::empty(response)),
25609            400u16..=499u16 => Err(Error::ErrorResponse(
25610                ResponseValue::from_response(response).await?,
25611            )),
25612            500u16..=599u16 => Err(Error::ErrorResponse(
25613                ResponseValue::from_response(response).await?,
25614            )),
25615            _ => Err(Error::UnexpectedResponse(response)),
25616        }
25617    }
25618
25619    ///Prefetch cache chunks
25620    ///
25621    ///Ensures specified file chunks are cached locally for a cache remote.
25622    ///
25623    ///Sends a `POST` request to `/cache/fetch`
25624    ///
25625    ///Arguments:
25626    /// - `async_`: Run the command asynchronously. Returns a job id
25627    ///   immediately.
25628    /// - `group`: Assign the request to a custom stats group.
25629    /// - `chunks`: Comma-separated chunk specifier list (e.g. `0:10,25:30`)
25630    ///   describing file pieces to prefetch.
25631    /// - `params`: Additional arbitrary parameters allowed.
25632    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25633    ///   instead of 200.
25634    /// - `body`
25635    pub async fn cache_fetch<'a>(
25636        &'a self,
25637        async_: Option<bool>,
25638        group: Option<&'a str>,
25639        chunks: Option<&'a str>,
25640        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25641        prefer: Option<types::CacheFetchPrefer>,
25642        body: &'a types::CacheFetchRequest,
25643    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
25644        let url = format!("{}/cache/fetch", self.baseurl,);
25645        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25646        header_map.append(
25647            ::reqwest::header::HeaderName::from_static("api-version"),
25648            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25649        );
25650        if let Some(value) = prefer {
25651            header_map.append("Prefer", value.to_string().try_into()?);
25652        }
25653
25654        #[allow(unused_mut)]
25655        let mut request = self
25656            .client
25657            .post(url)
25658            .header(
25659                ::reqwest::header::ACCEPT,
25660                ::reqwest::header::HeaderValue::from_static("application/json"),
25661            )
25662            .json(&body)
25663            .query(&progenitor_client::QueryParam::new("_async", &async_))
25664            .query(&progenitor_client::QueryParam::new("_group", &group))
25665            .query(&progenitor_client::QueryParam::new("chunks", &chunks))
25666            .query(&progenitor_client::QueryParam::new("params", &params))
25667            .headers(header_map)
25668            .build()?;
25669        let info = OperationInfo {
25670            operation_id: "cache_fetch",
25671        };
25672        self.pre(&mut request, &info).await?;
25673        let result = self.exec(request, &info).await;
25674        self.post(&result, &info).await?;
25675        let response = result?;
25676        match response.status().as_u16() {
25677            200u16 => Ok(ResponseValue::empty(response)),
25678            400u16..=499u16 => Err(Error::ErrorResponse(
25679                ResponseValue::from_response(response).await?,
25680            )),
25681            500u16..=599u16 => Err(Error::ErrorResponse(
25682                ResponseValue::from_response(response).await?,
25683            )),
25684            _ => Err(Error::UnexpectedResponse(response)),
25685        }
25686    }
25687
25688    ///Show cache stats
25689    ///
25690    ///Returns runtime statistics for the cache backend.
25691    ///
25692    ///Sends a `POST` request to `/cache/stats`
25693    ///
25694    ///Arguments:
25695    /// - `async_`: Run the command asynchronously. Returns a job id
25696    ///   immediately.
25697    /// - `group`: Assign the request to a custom stats group.
25698    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25699    ///   instead of 200.
25700    /// - `body`
25701    pub async fn cache_stats<'a>(
25702        &'a self,
25703        async_: Option<bool>,
25704        group: Option<&'a str>,
25705        prefer: Option<types::CacheStatsPrefer>,
25706        body: &'a types::CacheStatsRequest,
25707    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
25708        let url = format!("{}/cache/stats", self.baseurl,);
25709        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25710        header_map.append(
25711            ::reqwest::header::HeaderName::from_static("api-version"),
25712            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25713        );
25714        if let Some(value) = prefer {
25715            header_map.append("Prefer", value.to_string().try_into()?);
25716        }
25717
25718        #[allow(unused_mut)]
25719        let mut request = self
25720            .client
25721            .post(url)
25722            .header(
25723                ::reqwest::header::ACCEPT,
25724                ::reqwest::header::HeaderValue::from_static("application/json"),
25725            )
25726            .json(&body)
25727            .query(&progenitor_client::QueryParam::new("_async", &async_))
25728            .query(&progenitor_client::QueryParam::new("_group", &group))
25729            .headers(header_map)
25730            .build()?;
25731        let info = OperationInfo {
25732            operation_id: "cache_stats",
25733        };
25734        self.pre(&mut request, &info).await?;
25735        let result = self.exec(request, &info).await;
25736        self.post(&result, &info).await?;
25737        let response = result?;
25738        match response.status().as_u16() {
25739            200u16 => Ok(ResponseValue::empty(response)),
25740            400u16..=499u16 => Err(Error::ErrorResponse(
25741                ResponseValue::from_response(response).await?,
25742            )),
25743            500u16..=599u16 => Err(Error::ErrorResponse(
25744                ResponseValue::from_response(response).await?,
25745            )),
25746            _ => Err(Error::UnexpectedResponse(response)),
25747        }
25748    }
25749
25750    ///Create remote configuration
25751    ///
25752    ///Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
25753    ///
25754    ///Sends a `POST` request to `/config/create`
25755    ///
25756    ///Arguments:
25757    /// - `async_`: Run the command asynchronously. Returns a job id
25758    ///   immediately.
25759    /// - `group`: Assign the request to a custom stats group.
25760    /// - `name`: Name of the new remote configuration.
25761    /// - `opt`: Optional JSON object controlling interactive behaviour (e.g.
25762    ///   `obscure`, `continue`).
25763    /// - `parameters`: JSON object of configuration key/value pairs required
25764    ///   for the remote.
25765    /// - `type_`: Backend type identifier, such as `drive`, `s3`, or `dropbox`.
25766    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25767    ///   instead of 200.
25768    /// - `body`
25769    pub async fn config_create<'a>(
25770        &'a self,
25771        async_: Option<bool>,
25772        group: Option<&'a str>,
25773        name: Option<&'a str>,
25774        opt: Option<&'a str>,
25775        parameters: Option<&'a str>,
25776        type_: Option<&'a str>,
25777        prefer: Option<types::ConfigCreatePrefer>,
25778        body: &'a types::ConfigCreateRequest,
25779    ) -> Result<
25780        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
25781        Error<types::RcError>,
25782    > {
25783        let url = format!("{}/config/create", self.baseurl,);
25784        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25785        header_map.append(
25786            ::reqwest::header::HeaderName::from_static("api-version"),
25787            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25788        );
25789        if let Some(value) = prefer {
25790            header_map.append("Prefer", value.to_string().try_into()?);
25791        }
25792
25793        #[allow(unused_mut)]
25794        let mut request = self
25795            .client
25796            .post(url)
25797            .header(
25798                ::reqwest::header::ACCEPT,
25799                ::reqwest::header::HeaderValue::from_static("application/json"),
25800            )
25801            .json(&body)
25802            .query(&progenitor_client::QueryParam::new("_async", &async_))
25803            .query(&progenitor_client::QueryParam::new("_group", &group))
25804            .query(&progenitor_client::QueryParam::new("name", &name))
25805            .query(&progenitor_client::QueryParam::new("opt", &opt))
25806            .query(&progenitor_client::QueryParam::new(
25807                "parameters",
25808                &parameters,
25809            ))
25810            .query(&progenitor_client::QueryParam::new("type", &type_))
25811            .headers(header_map)
25812            .build()?;
25813        let info = OperationInfo {
25814            operation_id: "config_create",
25815        };
25816        self.pre(&mut request, &info).await?;
25817        let result = self.exec(request, &info).await;
25818        self.post(&result, &info).await?;
25819        let response = result?;
25820        match response.status().as_u16() {
25821            200u16 => ResponseValue::from_response(response).await,
25822            400u16..=499u16 => Err(Error::ErrorResponse(
25823                ResponseValue::from_response(response).await?,
25824            )),
25825            500u16..=599u16 => Err(Error::ErrorResponse(
25826                ResponseValue::from_response(response).await?,
25827            )),
25828            _ => Err(Error::UnexpectedResponse(response)),
25829        }
25830    }
25831
25832    ///Delete remote configuration
25833    ///
25834    ///Removes an existing remote from `rclone.conf`.
25835    ///
25836    ///Sends a `POST` request to `/config/delete`
25837    ///
25838    ///Arguments:
25839    /// - `async_`: Run the command asynchronously. Returns a job id
25840    ///   immediately.
25841    /// - `group`: Assign the request to a custom stats group.
25842    /// - `name`: Name of the remote configuration to delete.
25843    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25844    ///   instead of 200.
25845    /// - `body`
25846    pub async fn config_delete<'a>(
25847        &'a self,
25848        async_: Option<bool>,
25849        group: Option<&'a str>,
25850        name: Option<&'a str>,
25851        prefer: Option<types::ConfigDeletePrefer>,
25852        body: &'a types::ConfigDeleteRequest,
25853    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
25854        let url = format!("{}/config/delete", self.baseurl,);
25855        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25856        header_map.append(
25857            ::reqwest::header::HeaderName::from_static("api-version"),
25858            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25859        );
25860        if let Some(value) = prefer {
25861            header_map.append("Prefer", value.to_string().try_into()?);
25862        }
25863
25864        #[allow(unused_mut)]
25865        let mut request = self
25866            .client
25867            .post(url)
25868            .header(
25869                ::reqwest::header::ACCEPT,
25870                ::reqwest::header::HeaderValue::from_static("application/json"),
25871            )
25872            .json(&body)
25873            .query(&progenitor_client::QueryParam::new("_async", &async_))
25874            .query(&progenitor_client::QueryParam::new("_group", &group))
25875            .query(&progenitor_client::QueryParam::new("name", &name))
25876            .headers(header_map)
25877            .build()?;
25878        let info = OperationInfo {
25879            operation_id: "config_delete",
25880        };
25881        self.pre(&mut request, &info).await?;
25882        let result = self.exec(request, &info).await;
25883        self.post(&result, &info).await?;
25884        let response = result?;
25885        match response.status().as_u16() {
25886            200u16 => Ok(ResponseValue::empty(response)),
25887            400u16..=499u16 => Err(Error::ErrorResponse(
25888                ResponseValue::from_response(response).await?,
25889            )),
25890            500u16..=599u16 => Err(Error::ErrorResponse(
25891                ResponseValue::from_response(response).await?,
25892            )),
25893            _ => Err(Error::UnexpectedResponse(response)),
25894        }
25895    }
25896
25897    ///Dump configuration
25898    ///
25899    ///Returns the contents of the config file as a JSON object keyed by remote
25900    /// name.
25901    ///
25902    ///Sends a `POST` request to `/config/dump`
25903    ///
25904    ///Arguments:
25905    /// - `async_`: Run the command asynchronously. Returns a job id
25906    ///   immediately.
25907    /// - `group`: Assign the request to a custom stats group.
25908    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25909    ///   instead of 200.
25910    /// - `body`
25911    pub async fn config_dump<'a>(
25912        &'a self,
25913        async_: Option<bool>,
25914        group: Option<&'a str>,
25915        prefer: Option<types::ConfigDumpPrefer>,
25916        body: &'a types::ConfigDumpRequest,
25917    ) -> Result<
25918        ResponseValue<
25919            ::std::collections::HashMap<
25920                ::std::string::String,
25921                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
25922            >,
25923        >,
25924        Error<types::RcError>,
25925    > {
25926        let url = format!("{}/config/dump", self.baseurl,);
25927        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25928        header_map.append(
25929            ::reqwest::header::HeaderName::from_static("api-version"),
25930            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25931        );
25932        if let Some(value) = prefer {
25933            header_map.append("Prefer", value.to_string().try_into()?);
25934        }
25935
25936        #[allow(unused_mut)]
25937        let mut request = self
25938            .client
25939            .post(url)
25940            .header(
25941                ::reqwest::header::ACCEPT,
25942                ::reqwest::header::HeaderValue::from_static("application/json"),
25943            )
25944            .json(&body)
25945            .query(&progenitor_client::QueryParam::new("_async", &async_))
25946            .query(&progenitor_client::QueryParam::new("_group", &group))
25947            .headers(header_map)
25948            .build()?;
25949        let info = OperationInfo {
25950            operation_id: "config_dump",
25951        };
25952        self.pre(&mut request, &info).await?;
25953        let result = self.exec(request, &info).await;
25954        self.post(&result, &info).await?;
25955        let response = result?;
25956        match response.status().as_u16() {
25957            200u16 => ResponseValue::from_response(response).await,
25958            400u16..=499u16 => Err(Error::ErrorResponse(
25959                ResponseValue::from_response(response).await?,
25960            )),
25961            500u16..=599u16 => Err(Error::ErrorResponse(
25962                ResponseValue::from_response(response).await?,
25963            )),
25964            _ => Err(Error::UnexpectedResponse(response)),
25965        }
25966    }
25967
25968    ///Get remote configuration
25969    ///
25970    ///Returns the key/value settings for a single remote.
25971    ///
25972    ///Sends a `POST` request to `/config/get`
25973    ///
25974    ///Arguments:
25975    /// - `async_`: Run the command asynchronously. Returns a job id
25976    ///   immediately.
25977    /// - `group`: Assign the request to a custom stats group.
25978    /// - `name`: Name of the remote configuration to fetch.
25979    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
25980    ///   instead of 200.
25981    /// - `body`
25982    pub async fn config_get<'a>(
25983        &'a self,
25984        async_: Option<bool>,
25985        group: Option<&'a str>,
25986        name: Option<&'a str>,
25987        prefer: Option<types::ConfigGetPrefer>,
25988        body: &'a types::ConfigGetRequest,
25989    ) -> Result<ResponseValue<types::ConfigGetResponse>, Error<types::RcError>> {
25990        let url = format!("{}/config/get", self.baseurl,);
25991        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
25992        header_map.append(
25993            ::reqwest::header::HeaderName::from_static("api-version"),
25994            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
25995        );
25996        if let Some(value) = prefer {
25997            header_map.append("Prefer", value.to_string().try_into()?);
25998        }
25999
26000        #[allow(unused_mut)]
26001        let mut request = self
26002            .client
26003            .post(url)
26004            .header(
26005                ::reqwest::header::ACCEPT,
26006                ::reqwest::header::HeaderValue::from_static("application/json"),
26007            )
26008            .json(&body)
26009            .query(&progenitor_client::QueryParam::new("_async", &async_))
26010            .query(&progenitor_client::QueryParam::new("_group", &group))
26011            .query(&progenitor_client::QueryParam::new("name", &name))
26012            .headers(header_map)
26013            .build()?;
26014        let info = OperationInfo {
26015            operation_id: "config_get",
26016        };
26017        self.pre(&mut request, &info).await?;
26018        let result = self.exec(request, &info).await;
26019        self.post(&result, &info).await?;
26020        let response = result?;
26021        match response.status().as_u16() {
26022            200u16 => ResponseValue::from_response(response).await,
26023            400u16..=499u16 => Err(Error::ErrorResponse(
26024                ResponseValue::from_response(response).await?,
26025            )),
26026            500u16..=599u16 => Err(Error::ErrorResponse(
26027                ResponseValue::from_response(response).await?,
26028            )),
26029            _ => Err(Error::UnexpectedResponse(response)),
26030        }
26031    }
26032
26033    ///List configured remotes
26034    ///
26035    ///Returns the names of all remotes defined in the config file.
26036    ///
26037    ///Sends a `POST` request to `/config/listremotes`
26038    ///
26039    ///Arguments:
26040    /// - `async_`: Run the command asynchronously. Returns a job id
26041    ///   immediately.
26042    /// - `group`: Assign the request to a custom stats group.
26043    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26044    ///   instead of 200.
26045    /// - `body`
26046    pub async fn config_listremotes<'a>(
26047        &'a self,
26048        async_: Option<bool>,
26049        group: Option<&'a str>,
26050        prefer: Option<types::ConfigListremotesPrefer>,
26051        body: &'a types::ConfigListremotesRequest,
26052    ) -> Result<ResponseValue<types::ConfigListremotesResponse>, Error<types::RcError>> {
26053        let url = format!("{}/config/listremotes", self.baseurl,);
26054        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26055        header_map.append(
26056            ::reqwest::header::HeaderName::from_static("api-version"),
26057            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26058        );
26059        if let Some(value) = prefer {
26060            header_map.append("Prefer", value.to_string().try_into()?);
26061        }
26062
26063        #[allow(unused_mut)]
26064        let mut request = self
26065            .client
26066            .post(url)
26067            .header(
26068                ::reqwest::header::ACCEPT,
26069                ::reqwest::header::HeaderValue::from_static("application/json"),
26070            )
26071            .json(&body)
26072            .query(&progenitor_client::QueryParam::new("_async", &async_))
26073            .query(&progenitor_client::QueryParam::new("_group", &group))
26074            .headers(header_map)
26075            .build()?;
26076        let info = OperationInfo {
26077            operation_id: "config_listremotes",
26078        };
26079        self.pre(&mut request, &info).await?;
26080        let result = self.exec(request, &info).await;
26081        self.post(&result, &info).await?;
26082        let response = result?;
26083        match response.status().as_u16() {
26084            200u16 => ResponseValue::from_response(response).await,
26085            400u16..=499u16 => Err(Error::ErrorResponse(
26086                ResponseValue::from_response(response).await?,
26087            )),
26088            500u16..=599u16 => Err(Error::ErrorResponse(
26089                ResponseValue::from_response(response).await?,
26090            )),
26091            _ => Err(Error::UnexpectedResponse(response)),
26092        }
26093    }
26094
26095    ///Get OAuth server status
26096    ///
26097    ///Returns the status of the interactive OAuth authentication server,
26098    /// including the authorization URL when it is running.
26099    ///
26100    ///Sends a `POST` request to `/config/oauthstatus`
26101    ///
26102    ///Arguments:
26103    /// - `async_`: Run the command asynchronously. Returns a job id
26104    ///   immediately.
26105    /// - `group`: Assign the request to a custom stats group.
26106    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26107    ///   instead of 200.
26108    /// - `body`
26109    pub async fn config_oauthstatus<'a>(
26110        &'a self,
26111        async_: Option<bool>,
26112        group: Option<&'a str>,
26113        prefer: Option<types::ConfigOauthstatusPrefer>,
26114        body: &'a types::ConfigOauthstatusRequest,
26115    ) -> Result<ResponseValue<types::ConfigOauthstatusResponse>, Error<types::RcError>> {
26116        let url = format!("{}/config/oauthstatus", self.baseurl,);
26117        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26118        header_map.append(
26119            ::reqwest::header::HeaderName::from_static("api-version"),
26120            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26121        );
26122        if let Some(value) = prefer {
26123            header_map.append("Prefer", value.to_string().try_into()?);
26124        }
26125
26126        #[allow(unused_mut)]
26127        let mut request = self
26128            .client
26129            .post(url)
26130            .header(
26131                ::reqwest::header::ACCEPT,
26132                ::reqwest::header::HeaderValue::from_static("application/json"),
26133            )
26134            .json(&body)
26135            .query(&progenitor_client::QueryParam::new("_async", &async_))
26136            .query(&progenitor_client::QueryParam::new("_group", &group))
26137            .headers(header_map)
26138            .build()?;
26139        let info = OperationInfo {
26140            operation_id: "config_oauthstatus",
26141        };
26142        self.pre(&mut request, &info).await?;
26143        let result = self.exec(request, &info).await;
26144        self.post(&result, &info).await?;
26145        let response = result?;
26146        match response.status().as_u16() {
26147            200u16 => ResponseValue::from_response(response).await,
26148            400u16..=499u16 => Err(Error::ErrorResponse(
26149                ResponseValue::from_response(response).await?,
26150            )),
26151            500u16..=599u16 => Err(Error::ErrorResponse(
26152                ResponseValue::from_response(response).await?,
26153            )),
26154            _ => Err(Error::UnexpectedResponse(response)),
26155        }
26156    }
26157
26158    ///Stop OAuth server
26159    ///
26160    ///Stops the interactive OAuth authentication server if one is running.
26161    /// Returns an error if no OAuth flow is in progress.
26162    ///
26163    ///Sends a `POST` request to `/config/oauthstop`
26164    ///
26165    ///Arguments:
26166    /// - `async_`: Run the command asynchronously. Returns a job id
26167    ///   immediately.
26168    /// - `group`: Assign the request to a custom stats group.
26169    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26170    ///   instead of 200.
26171    /// - `body`
26172    pub async fn config_oauthstop<'a>(
26173        &'a self,
26174        async_: Option<bool>,
26175        group: Option<&'a str>,
26176        prefer: Option<types::ConfigOauthstopPrefer>,
26177        body: &'a types::ConfigOauthstopRequest,
26178    ) -> Result<
26179        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
26180        Error<types::RcError>,
26181    > {
26182        let url = format!("{}/config/oauthstop", self.baseurl,);
26183        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26184        header_map.append(
26185            ::reqwest::header::HeaderName::from_static("api-version"),
26186            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26187        );
26188        if let Some(value) = prefer {
26189            header_map.append("Prefer", value.to_string().try_into()?);
26190        }
26191
26192        #[allow(unused_mut)]
26193        let mut request = self
26194            .client
26195            .post(url)
26196            .header(
26197                ::reqwest::header::ACCEPT,
26198                ::reqwest::header::HeaderValue::from_static("application/json"),
26199            )
26200            .json(&body)
26201            .query(&progenitor_client::QueryParam::new("_async", &async_))
26202            .query(&progenitor_client::QueryParam::new("_group", &group))
26203            .headers(header_map)
26204            .build()?;
26205        let info = OperationInfo {
26206            operation_id: "config_oauthstop",
26207        };
26208        self.pre(&mut request, &info).await?;
26209        let result = self.exec(request, &info).await;
26210        self.post(&result, &info).await?;
26211        let response = result?;
26212        match response.status().as_u16() {
26213            200u16 => ResponseValue::from_response(response).await,
26214            400u16..=499u16 => Err(Error::ErrorResponse(
26215                ResponseValue::from_response(response).await?,
26216            )),
26217            500u16..=599u16 => Err(Error::ErrorResponse(
26218                ResponseValue::from_response(response).await?,
26219            )),
26220            _ => Err(Error::UnexpectedResponse(response)),
26221        }
26222    }
26223
26224    ///Update remote secrets
26225    ///
26226    ///Sets obscured password fields for a remote configuration.
26227    ///
26228    ///Sends a `POST` request to `/config/password`
26229    ///
26230    ///Arguments:
26231    /// - `async_`: Run the command asynchronously. Returns a job id
26232    ///   immediately.
26233    /// - `group`: Assign the request to a custom stats group.
26234    /// - `name`: Name of the remote whose secrets should be updated.
26235    /// - `parameters`: JSON object of password answers, typically including
26236    ///   `pass`.
26237    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26238    ///   instead of 200.
26239    /// - `body`
26240    pub async fn config_password<'a>(
26241        &'a self,
26242        async_: Option<bool>,
26243        group: Option<&'a str>,
26244        name: Option<&'a str>,
26245        parameters: Option<&'a str>,
26246        prefer: Option<types::ConfigPasswordPrefer>,
26247        body: &'a types::ConfigPasswordRequest,
26248    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
26249        let url = format!("{}/config/password", self.baseurl,);
26250        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26251        header_map.append(
26252            ::reqwest::header::HeaderName::from_static("api-version"),
26253            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26254        );
26255        if let Some(value) = prefer {
26256            header_map.append("Prefer", value.to_string().try_into()?);
26257        }
26258
26259        #[allow(unused_mut)]
26260        let mut request = self
26261            .client
26262            .post(url)
26263            .header(
26264                ::reqwest::header::ACCEPT,
26265                ::reqwest::header::HeaderValue::from_static("application/json"),
26266            )
26267            .json(&body)
26268            .query(&progenitor_client::QueryParam::new("_async", &async_))
26269            .query(&progenitor_client::QueryParam::new("_group", &group))
26270            .query(&progenitor_client::QueryParam::new("name", &name))
26271            .query(&progenitor_client::QueryParam::new(
26272                "parameters",
26273                &parameters,
26274            ))
26275            .headers(header_map)
26276            .build()?;
26277        let info = OperationInfo {
26278            operation_id: "config_password",
26279        };
26280        self.pre(&mut request, &info).await?;
26281        let result = self.exec(request, &info).await;
26282        self.post(&result, &info).await?;
26283        let response = result?;
26284        match response.status().as_u16() {
26285            200u16 => Ok(ResponseValue::empty(response)),
26286            400u16..=499u16 => Err(Error::ErrorResponse(
26287                ResponseValue::from_response(response).await?,
26288            )),
26289            500u16..=599u16 => Err(Error::ErrorResponse(
26290                ResponseValue::from_response(response).await?,
26291            )),
26292            _ => Err(Error::UnexpectedResponse(response)),
26293        }
26294    }
26295
26296    ///Show config paths
26297    ///
26298    ///Returns the paths to the config file, cache directory, and temporary
26299    /// directory.
26300    ///
26301    ///Sends a `POST` request to `/config/paths`
26302    ///
26303    ///Arguments:
26304    /// - `async_`: Run the command asynchronously. Returns a job id
26305    ///   immediately.
26306    /// - `group`: Assign the request to a custom stats group.
26307    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26308    ///   instead of 200.
26309    /// - `body`
26310    pub async fn config_paths<'a>(
26311        &'a self,
26312        async_: Option<bool>,
26313        group: Option<&'a str>,
26314        prefer: Option<types::ConfigPathsPrefer>,
26315        body: &'a types::ConfigPathsRequest,
26316    ) -> Result<ResponseValue<types::ConfigPathsResponse>, Error<types::RcError>> {
26317        let url = format!("{}/config/paths", self.baseurl,);
26318        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26319        header_map.append(
26320            ::reqwest::header::HeaderName::from_static("api-version"),
26321            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26322        );
26323        if let Some(value) = prefer {
26324            header_map.append("Prefer", value.to_string().try_into()?);
26325        }
26326
26327        #[allow(unused_mut)]
26328        let mut request = self
26329            .client
26330            .post(url)
26331            .header(
26332                ::reqwest::header::ACCEPT,
26333                ::reqwest::header::HeaderValue::from_static("application/json"),
26334            )
26335            .json(&body)
26336            .query(&progenitor_client::QueryParam::new("_async", &async_))
26337            .query(&progenitor_client::QueryParam::new("_group", &group))
26338            .headers(header_map)
26339            .build()?;
26340        let info = OperationInfo {
26341            operation_id: "config_paths",
26342        };
26343        self.pre(&mut request, &info).await?;
26344        let result = self.exec(request, &info).await;
26345        self.post(&result, &info).await?;
26346        let response = result?;
26347        match response.status().as_u16() {
26348            200u16 => ResponseValue::from_response(response).await,
26349            400u16..=499u16 => Err(Error::ErrorResponse(
26350                ResponseValue::from_response(response).await?,
26351            )),
26352            500u16..=599u16 => Err(Error::ErrorResponse(
26353                ResponseValue::from_response(response).await?,
26354            )),
26355            _ => Err(Error::UnexpectedResponse(response)),
26356        }
26357    }
26358
26359    ///List backend providers
26360    ///
26361    ///Returns metadata describing each supported storage provider.
26362    ///
26363    ///Sends a `POST` request to `/config/providers`
26364    ///
26365    ///Arguments:
26366    /// - `async_`: Run the command asynchronously. Returns a job id
26367    ///   immediately.
26368    /// - `group`: Assign the request to a custom stats group.
26369    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26370    ///   instead of 200.
26371    /// - `body`
26372    pub async fn config_providers<'a>(
26373        &'a self,
26374        async_: Option<bool>,
26375        group: Option<&'a str>,
26376        prefer: Option<types::ConfigProvidersPrefer>,
26377        body: &'a types::ConfigProvidersRequest,
26378    ) -> Result<ResponseValue<types::ConfigProvidersResponse>, Error<types::RcError>> {
26379        let url = format!("{}/config/providers", self.baseurl,);
26380        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26381        header_map.append(
26382            ::reqwest::header::HeaderName::from_static("api-version"),
26383            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26384        );
26385        if let Some(value) = prefer {
26386            header_map.append("Prefer", value.to_string().try_into()?);
26387        }
26388
26389        #[allow(unused_mut)]
26390        let mut request = self
26391            .client
26392            .post(url)
26393            .header(
26394                ::reqwest::header::ACCEPT,
26395                ::reqwest::header::HeaderValue::from_static("application/json"),
26396            )
26397            .json(&body)
26398            .query(&progenitor_client::QueryParam::new("_async", &async_))
26399            .query(&progenitor_client::QueryParam::new("_group", &group))
26400            .headers(header_map)
26401            .build()?;
26402        let info = OperationInfo {
26403            operation_id: "config_providers",
26404        };
26405        self.pre(&mut request, &info).await?;
26406        let result = self.exec(request, &info).await;
26407        self.post(&result, &info).await?;
26408        let response = result?;
26409        match response.status().as_u16() {
26410            200u16 => ResponseValue::from_response(response).await,
26411            400u16..=499u16 => Err(Error::ErrorResponse(
26412                ResponseValue::from_response(response).await?,
26413            )),
26414            500u16..=599u16 => Err(Error::ErrorResponse(
26415                ResponseValue::from_response(response).await?,
26416            )),
26417            _ => Err(Error::UnexpectedResponse(response)),
26418        }
26419    }
26420
26421    ///Set config path
26422    ///
26423    ///Points rclone at a specific `rclone.conf` file.
26424    ///
26425    ///Sends a `POST` request to `/config/setpath`
26426    ///
26427    ///Arguments:
26428    /// - `async_`: Run the command asynchronously. Returns a job id
26429    ///   immediately.
26430    /// - `group`: Assign the request to a custom stats group.
26431    /// - `path`: Absolute path to the `rclone.conf` file that rclone should
26432    ///   use.
26433    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26434    ///   instead of 200.
26435    /// - `body`
26436    pub async fn config_setpath<'a>(
26437        &'a self,
26438        async_: Option<bool>,
26439        group: Option<&'a str>,
26440        path: Option<&'a str>,
26441        prefer: Option<types::ConfigSetpathPrefer>,
26442        body: &'a types::ConfigSetpathRequest,
26443    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
26444        let url = format!("{}/config/setpath", self.baseurl,);
26445        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26446        header_map.append(
26447            ::reqwest::header::HeaderName::from_static("api-version"),
26448            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26449        );
26450        if let Some(value) = prefer {
26451            header_map.append("Prefer", value.to_string().try_into()?);
26452        }
26453
26454        #[allow(unused_mut)]
26455        let mut request = self
26456            .client
26457            .post(url)
26458            .header(
26459                ::reqwest::header::ACCEPT,
26460                ::reqwest::header::HeaderValue::from_static("application/json"),
26461            )
26462            .json(&body)
26463            .query(&progenitor_client::QueryParam::new("_async", &async_))
26464            .query(&progenitor_client::QueryParam::new("_group", &group))
26465            .query(&progenitor_client::QueryParam::new("path", &path))
26466            .headers(header_map)
26467            .build()?;
26468        let info = OperationInfo {
26469            operation_id: "config_setpath",
26470        };
26471        self.pre(&mut request, &info).await?;
26472        let result = self.exec(request, &info).await;
26473        self.post(&result, &info).await?;
26474        let response = result?;
26475        match response.status().as_u16() {
26476            200u16 => Ok(ResponseValue::empty(response)),
26477            400u16..=499u16 => Err(Error::ErrorResponse(
26478                ResponseValue::from_response(response).await?,
26479            )),
26480            500u16..=599u16 => Err(Error::ErrorResponse(
26481                ResponseValue::from_response(response).await?,
26482            )),
26483            _ => Err(Error::UnexpectedResponse(response)),
26484        }
26485    }
26486
26487    ///Unlock encrypted config
26488    ///
26489    ///Unlocks the configuration file using the provided password.
26490    ///
26491    ///Sends a `POST` request to `/config/unlock`
26492    ///
26493    ///Arguments:
26494    /// - `async_`: Run the command asynchronously. Returns a job id
26495    ///   immediately.
26496    /// - `group`: Assign the request to a custom stats group.
26497    /// - `config_password`: Password used to unlock an encrypted config file.
26498    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26499    ///   instead of 200.
26500    /// - `body`
26501    pub async fn config_unlock<'a>(
26502        &'a self,
26503        async_: Option<bool>,
26504        group: Option<&'a str>,
26505        config_password: Option<&'a str>,
26506        prefer: Option<types::ConfigUnlockPrefer>,
26507        body: &'a types::ConfigUnlockRequest,
26508    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
26509        let url = format!("{}/config/unlock", self.baseurl,);
26510        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26511        header_map.append(
26512            ::reqwest::header::HeaderName::from_static("api-version"),
26513            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26514        );
26515        if let Some(value) = prefer {
26516            header_map.append("Prefer", value.to_string().try_into()?);
26517        }
26518
26519        #[allow(unused_mut)]
26520        let mut request = self
26521            .client
26522            .post(url)
26523            .header(
26524                ::reqwest::header::ACCEPT,
26525                ::reqwest::header::HeaderValue::from_static("application/json"),
26526            )
26527            .json(&body)
26528            .query(&progenitor_client::QueryParam::new("_async", &async_))
26529            .query(&progenitor_client::QueryParam::new("_group", &group))
26530            .query(&progenitor_client::QueryParam::new(
26531                "configPassword",
26532                &config_password,
26533            ))
26534            .headers(header_map)
26535            .build()?;
26536        let info = OperationInfo {
26537            operation_id: "config_unlock",
26538        };
26539        self.pre(&mut request, &info).await?;
26540        let result = self.exec(request, &info).await;
26541        self.post(&result, &info).await?;
26542        let response = result?;
26543        match response.status().as_u16() {
26544            200u16 => Ok(ResponseValue::empty(response)),
26545            400u16..=499u16 => Err(Error::ErrorResponse(
26546                ResponseValue::from_response(response).await?,
26547            )),
26548            500u16..=599u16 => Err(Error::ErrorResponse(
26549                ResponseValue::from_response(response).await?,
26550            )),
26551            _ => Err(Error::UnexpectedResponse(response)),
26552        }
26553    }
26554
26555    ///Update remote configuration
26556    ///
26557    ///Updates an existing remote with new parameter values.
26558    ///
26559    ///Sends a `POST` request to `/config/update`
26560    ///
26561    ///Arguments:
26562    /// - `async_`: Run the command asynchronously. Returns a job id
26563    ///   immediately.
26564    /// - `group`: Assign the request to a custom stats group.
26565    /// - `name`: Name of the remote configuration to update.
26566    /// - `opt`: Optional JSON object controlling update behaviour (e.g.
26567    ///   `obscure`, `continue`).
26568    /// - `parameters`: JSON object of configuration key/value pairs to apply to
26569    ///   the remote.
26570    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26571    ///   instead of 200.
26572    /// - `body`
26573    pub async fn config_update<'a>(
26574        &'a self,
26575        async_: Option<bool>,
26576        group: Option<&'a str>,
26577        name: Option<&'a str>,
26578        opt: Option<&'a str>,
26579        parameters: Option<&'a str>,
26580        prefer: Option<types::ConfigUpdatePrefer>,
26581        body: &'a types::ConfigUpdateRequest,
26582    ) -> Result<
26583        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
26584        Error<types::RcError>,
26585    > {
26586        let url = format!("{}/config/update", self.baseurl,);
26587        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26588        header_map.append(
26589            ::reqwest::header::HeaderName::from_static("api-version"),
26590            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26591        );
26592        if let Some(value) = prefer {
26593            header_map.append("Prefer", value.to_string().try_into()?);
26594        }
26595
26596        #[allow(unused_mut)]
26597        let mut request = self
26598            .client
26599            .post(url)
26600            .header(
26601                ::reqwest::header::ACCEPT,
26602                ::reqwest::header::HeaderValue::from_static("application/json"),
26603            )
26604            .json(&body)
26605            .query(&progenitor_client::QueryParam::new("_async", &async_))
26606            .query(&progenitor_client::QueryParam::new("_group", &group))
26607            .query(&progenitor_client::QueryParam::new("name", &name))
26608            .query(&progenitor_client::QueryParam::new("opt", &opt))
26609            .query(&progenitor_client::QueryParam::new(
26610                "parameters",
26611                &parameters,
26612            ))
26613            .headers(header_map)
26614            .build()?;
26615        let info = OperationInfo {
26616            operation_id: "config_update",
26617        };
26618        self.pre(&mut request, &info).await?;
26619        let result = self.exec(request, &info).await;
26620        self.post(&result, &info).await?;
26621        let response = result?;
26622        match response.status().as_u16() {
26623            200u16 => ResponseValue::from_response(response).await,
26624            400u16..=499u16 => Err(Error::ErrorResponse(
26625                ResponseValue::from_response(response).await?,
26626            )),
26627            500u16..=599u16 => Err(Error::ErrorResponse(
26628                ResponseValue::from_response(response).await?,
26629            )),
26630            _ => Err(Error::UnexpectedResponse(response)),
26631        }
26632    }
26633
26634    ///Report rclone version
26635    ///
26636    ///Returns the running rclone version, build metadata, and Go runtime
26637    /// details.
26638    ///
26639    ///Sends a `POST` request to `/core/version`
26640    ///
26641    ///Arguments:
26642    /// - `async_`: Run the command asynchronously. Returns a job id
26643    ///   immediately.
26644    /// - `group`: Assign the request to a custom stats group.
26645    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26646    ///   instead of 200.
26647    /// - `body`
26648    pub async fn core_version<'a>(
26649        &'a self,
26650        async_: Option<bool>,
26651        group: Option<&'a str>,
26652        prefer: Option<types::CoreVersionPrefer>,
26653        body: &'a types::CoreVersionRequest,
26654    ) -> Result<ResponseValue<types::CoreVersionResponse>, Error<types::RcError>> {
26655        let url = format!("{}/core/version", self.baseurl,);
26656        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26657        header_map.append(
26658            ::reqwest::header::HeaderName::from_static("api-version"),
26659            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26660        );
26661        if let Some(value) = prefer {
26662            header_map.append("Prefer", value.to_string().try_into()?);
26663        }
26664
26665        #[allow(unused_mut)]
26666        let mut request = self
26667            .client
26668            .post(url)
26669            .header(
26670                ::reqwest::header::ACCEPT,
26671                ::reqwest::header::HeaderValue::from_static("application/json"),
26672            )
26673            .json(&body)
26674            .query(&progenitor_client::QueryParam::new("_async", &async_))
26675            .query(&progenitor_client::QueryParam::new("_group", &group))
26676            .headers(header_map)
26677            .build()?;
26678        let info = OperationInfo {
26679            operation_id: "core_version",
26680        };
26681        self.pre(&mut request, &info).await?;
26682        let result = self.exec(request, &info).await;
26683        self.post(&result, &info).await?;
26684        let response = result?;
26685        match response.status().as_u16() {
26686            200u16 => ResponseValue::from_response(response).await,
26687            400u16..=499u16 => Err(Error::ErrorResponse(
26688                ResponseValue::from_response(response).await?,
26689            )),
26690            500u16..=599u16 => Err(Error::ErrorResponse(
26691                ResponseValue::from_response(response).await?,
26692            )),
26693            _ => Err(Error::UnexpectedResponse(response)),
26694        }
26695    }
26696
26697    ///Current stats snapshot
26698    ///
26699    ///Returns active transfer statistics including bytes transferred, speed,
26700    /// and error counts.
26701    ///
26702    ///Sends a `POST` request to `/core/stats`
26703    ///
26704    ///Arguments:
26705    /// - `async_`: Run the command asynchronously. Returns a job id
26706    ///   immediately.
26707    /// - `group`: Assign the request to a custom stats group.
26708    /// - `group`: Stats group identifier to return a snapshot for. Leave unset
26709    ///   to include all groups.
26710    /// - `short`: When true, omit the `transferring` and `checking` arrays from
26711    ///   the response.
26712    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26713    ///   instead of 200.
26714    /// - `body`
26715    pub async fn core_stats<'a>(
26716        &'a self,
26717        async_: Option<bool>,
26718        group_: Option<&'a str>,
26719        group: Option<&'a str>,
26720        short: Option<bool>,
26721        prefer: Option<types::CoreStatsPrefer>,
26722        body: &'a types::CoreStatsRequest
26723    ) -> Result<ResponseValue<types::CoreStatsResponse>, Error<types::RcError>> {
26724        let url = format!("{}/core/stats", self.baseurl,);
26725        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26726        header_map.append(
26727            ::reqwest::header::HeaderName::from_static("api-version"),
26728            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26729        );
26730        if let Some(value) = prefer {
26731            header_map.append("Prefer", value.to_string().try_into()?);
26732        }
26733
26734        #[allow(unused_mut)]
26735        let mut request = self
26736            .client
26737            .post(url)
26738            .header(
26739                ::reqwest::header::ACCEPT,
26740                ::reqwest::header::HeaderValue::from_static("application/json"),
26741            )
26742            .json(&body)
26743            .query(&progenitor_client::QueryParam::new("_async", &async_))
26744            .query(&progenitor_client::QueryParam::new("_group", &group))
26745            .query(&progenitor_client::QueryParam::new("group", &group))
26746            .query(&progenitor_client::QueryParam::new("short", &short))
26747            .headers(header_map)
26748            .build()?;
26749        let info = OperationInfo {
26750            operation_id: "core_stats",
26751        };
26752        self.pre(&mut request, &info).await?;
26753        let result = self.exec(request, &info).await;
26754        self.post(&result, &info).await?;
26755        let response = result?;
26756        match response.status().as_u16() {
26757            200u16 => ResponseValue::from_response(response).await,
26758            400u16..=499u16 => Err(Error::ErrorResponse(
26759                ResponseValue::from_response(response).await?,
26760            )),
26761            500u16..=599u16 => Err(Error::ErrorResponse(
26762                ResponseValue::from_response(response).await?,
26763            )),
26764            _ => Err(Error::UnexpectedResponse(response)),
26765        }
26766    }
26767
26768    ///Run batch of commands
26769    ///
26770    ///Run a batch of rclone rc commands concurrently.
26771    ///
26772    ///Sends a `POST` request to `/job/batch`
26773    ///
26774    ///Arguments:
26775    /// - `async_`: Run the command asynchronously. Returns a job id
26776    ///   immediately.
26777    /// - `concurrency`: Do this many commands concurrently. Defaults to
26778    ///   --transfers if not set.
26779    /// - `inputs`: List of inputs to the commands with an extra _path
26780    ///   parameter.
26781    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26782    ///   instead of 200.
26783    /// - `body`
26784    pub async fn job_batch<'a>(
26785        &'a self,
26786        async_: Option<bool>,
26787        concurrency: Option<i64>,
26788        inputs: Option<&'a ::std::vec::Vec<types::JobBatchInputsItem>>,
26789        prefer: Option<types::JobBatchPrefer>,
26790        body: &'a types::JobBatchRequest,
26791    ) -> Result<ResponseValue<types::JobBatchResponse>, Error<types::RcError>> {
26792        let url = format!("{}/job/batch", self.baseurl,);
26793        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26794        header_map.append(
26795            ::reqwest::header::HeaderName::from_static("api-version"),
26796            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26797        );
26798        if let Some(value) = prefer {
26799            header_map.append("Prefer", value.to_string().try_into()?);
26800        }
26801
26802        #[allow(unused_mut)]
26803        let mut request = self
26804            .client
26805            .post(url)
26806            .header(
26807                ::reqwest::header::ACCEPT,
26808                ::reqwest::header::HeaderValue::from_static("application/json"),
26809            )
26810            .json(&body)
26811            .query(&progenitor_client::QueryParam::new("_async", &async_))
26812            .query(&progenitor_client::QueryParam::new(
26813                "concurrency",
26814                &concurrency,
26815            ))
26816            .query(&progenitor_client::QueryParam::new("inputs", &inputs))
26817            .headers(header_map)
26818            .build()?;
26819        let info = OperationInfo {
26820            operation_id: "job_batch",
26821        };
26822        self.pre(&mut request, &info).await?;
26823        let result = self.exec(request, &info).await;
26824        self.post(&result, &info).await?;
26825        let response = result?;
26826        match response.status().as_u16() {
26827            200u16 => ResponseValue::from_response(response).await,
26828            400u16..=499u16 => Err(Error::ErrorResponse(
26829                ResponseValue::from_response(response).await?,
26830            )),
26831            500u16..=599u16 => Err(Error::ErrorResponse(
26832                ResponseValue::from_response(response).await?,
26833            )),
26834            _ => Err(Error::UnexpectedResponse(response)),
26835        }
26836    }
26837
26838    ///List jobs
26839    ///
26840    ///Returns identifiers of active and recently completed asynchronous jobs.
26841    ///
26842    ///Sends a `POST` request to `/job/list`
26843    ///
26844    ///Arguments:
26845    /// - `async_`: Run the command asynchronously. Returns a job id
26846    ///   immediately.
26847    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26848    ///   instead of 200.
26849    /// - `body`
26850    pub async fn job_list<'a>(
26851        &'a self,
26852        async_: Option<bool>,
26853        prefer: Option<types::JobListPrefer>,
26854        body: &'a types::JobListRequest,
26855    ) -> Result<ResponseValue<types::JobListResponse>, Error<types::RcError>> {
26856        let url = format!("{}/job/list", self.baseurl,);
26857        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26858        header_map.append(
26859            ::reqwest::header::HeaderName::from_static("api-version"),
26860            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26861        );
26862        if let Some(value) = prefer {
26863            header_map.append("Prefer", value.to_string().try_into()?);
26864        }
26865
26866        #[allow(unused_mut)]
26867        let mut request = self
26868            .client
26869            .post(url)
26870            .header(
26871                ::reqwest::header::ACCEPT,
26872                ::reqwest::header::HeaderValue::from_static("application/json"),
26873            )
26874            .json(&body)
26875            .query(&progenitor_client::QueryParam::new("_async", &async_))
26876            .headers(header_map)
26877            .build()?;
26878        let info = OperationInfo {
26879            operation_id: "job_list",
26880        };
26881        self.pre(&mut request, &info).await?;
26882        let result = self.exec(request, &info).await;
26883        self.post(&result, &info).await?;
26884        let response = result?;
26885        match response.status().as_u16() {
26886            200u16 => ResponseValue::from_response(response).await,
26887            400u16..=499u16 => Err(Error::ErrorResponse(
26888                ResponseValue::from_response(response).await?,
26889            )),
26890            500u16..=599u16 => Err(Error::ErrorResponse(
26891                ResponseValue::from_response(response).await?,
26892            )),
26893            _ => Err(Error::UnexpectedResponse(response)),
26894        }
26895    }
26896
26897    ///Get job status
26898    ///
26899    ///Returns timing, success state, output, and progress for a specific job.
26900    ///
26901    ///Sends a `POST` request to `/job/status`
26902    ///
26903    ///Arguments:
26904    /// - `async_`: Run the command asynchronously. Returns a job id
26905    ///   immediately.
26906    /// - `jobid`: Numeric identifier of the job to query, as returned from an
26907    ///   async call.
26908    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26909    ///   instead of 200.
26910    /// - `body`
26911    pub async fn job_status<'a>(
26912        &'a self,
26913        async_: Option<bool>,
26914        jobid: Option<f64>,
26915        prefer: Option<types::JobStatusPrefer>,
26916        body: &'a types::JobStatusRequest,
26917    ) -> Result<ResponseValue<types::JobStatusResponse>, Error<types::RcError>> {
26918        let url = format!("{}/job/status", self.baseurl,);
26919        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26920        header_map.append(
26921            ::reqwest::header::HeaderName::from_static("api-version"),
26922            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26923        );
26924        if let Some(value) = prefer {
26925            header_map.append("Prefer", value.to_string().try_into()?);
26926        }
26927
26928        #[allow(unused_mut)]
26929        let mut request = self
26930            .client
26931            .post(url)
26932            .header(
26933                ::reqwest::header::ACCEPT,
26934                ::reqwest::header::HeaderValue::from_static("application/json"),
26935            )
26936            .json(&body)
26937            .query(&progenitor_client::QueryParam::new("_async", &async_))
26938            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
26939            .headers(header_map)
26940            .build()?;
26941        let info = OperationInfo {
26942            operation_id: "job_status",
26943        };
26944        self.pre(&mut request, &info).await?;
26945        let result = self.exec(request, &info).await;
26946        self.post(&result, &info).await?;
26947        let response = result?;
26948        match response.status().as_u16() {
26949            200u16 => ResponseValue::from_response(response).await,
26950            400u16..=499u16 => Err(Error::ErrorResponse(
26951                ResponseValue::from_response(response).await?,
26952            )),
26953            500u16..=599u16 => Err(Error::ErrorResponse(
26954                ResponseValue::from_response(response).await?,
26955            )),
26956            _ => Err(Error::UnexpectedResponse(response)),
26957        }
26958    }
26959
26960    ///Stop job
26961    ///
26962    ///Attempts to cancel a running job by ID.
26963    ///
26964    ///Sends a `POST` request to `/job/stop`
26965    ///
26966    ///Arguments:
26967    /// - `async_`: Run the command asynchronously. Returns a job id
26968    ///   immediately.
26969    /// - `jobid`: Numeric identifier of the job to cancel.
26970    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
26971    ///   instead of 200.
26972    /// - `body`
26973    pub async fn job_stop<'a>(
26974        &'a self,
26975        async_: Option<bool>,
26976        jobid: Option<f64>,
26977        prefer: Option<types::JobStopPrefer>,
26978        body: &'a types::JobStopRequest,
26979    ) -> Result<
26980        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
26981        Error<types::RcError>,
26982    > {
26983        let url = format!("{}/job/stop", self.baseurl,);
26984        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
26985        header_map.append(
26986            ::reqwest::header::HeaderName::from_static("api-version"),
26987            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
26988        );
26989        if let Some(value) = prefer {
26990            header_map.append("Prefer", value.to_string().try_into()?);
26991        }
26992
26993        #[allow(unused_mut)]
26994        let mut request = self
26995            .client
26996            .post(url)
26997            .header(
26998                ::reqwest::header::ACCEPT,
26999                ::reqwest::header::HeaderValue::from_static("application/json"),
27000            )
27001            .json(&body)
27002            .query(&progenitor_client::QueryParam::new("_async", &async_))
27003            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
27004            .headers(header_map)
27005            .build()?;
27006        let info = OperationInfo {
27007            operation_id: "job_stop",
27008        };
27009        self.pre(&mut request, &info).await?;
27010        let result = self.exec(request, &info).await;
27011        self.post(&result, &info).await?;
27012        let response = result?;
27013        match response.status().as_u16() {
27014            200u16 => ResponseValue::from_response(response).await,
27015            400u16..=499u16 => Err(Error::ErrorResponse(
27016                ResponseValue::from_response(response).await?,
27017            )),
27018            500u16..=599u16 => Err(Error::ErrorResponse(
27019                ResponseValue::from_response(response).await?,
27020            )),
27021            _ => Err(Error::UnexpectedResponse(response)),
27022        }
27023    }
27024
27025    ///Stop jobs in group
27026    ///
27027    ///Cancels all active jobs associated with the provided stats group.
27028    ///
27029    ///Sends a `POST` request to `/job/stopgroup`
27030    ///
27031    ///Arguments:
27032    /// - `async_`: Run the command asynchronously. Returns a job id
27033    ///   immediately.
27034    /// - `group`: Stats group name whose active jobs should be stopped.
27035    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27036    ///   instead of 200.
27037    /// - `body`
27038    pub async fn job_stopgroup<'a>(
27039        &'a self,
27040        async_: Option<bool>,
27041        group: Option<&'a str>,
27042        prefer: Option<types::JobStopgroupPrefer>,
27043        body: &'a types::JobStopgroupRequest,
27044    ) -> Result<
27045        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27046        Error<types::RcError>,
27047    > {
27048        let url = format!("{}/job/stopgroup", self.baseurl,);
27049        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27050        header_map.append(
27051            ::reqwest::header::HeaderName::from_static("api-version"),
27052            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27053        );
27054        if let Some(value) = prefer {
27055            header_map.append("Prefer", value.to_string().try_into()?);
27056        }
27057
27058        #[allow(unused_mut)]
27059        let mut request = self
27060            .client
27061            .post(url)
27062            .header(
27063                ::reqwest::header::ACCEPT,
27064                ::reqwest::header::HeaderValue::from_static("application/json"),
27065            )
27066            .json(&body)
27067            .query(&progenitor_client::QueryParam::new("_async", &async_))
27068            .query(&progenitor_client::QueryParam::new("group", &group))
27069            .headers(header_map)
27070            .build()?;
27071        let info = OperationInfo {
27072            operation_id: "job_stopgroup",
27073        };
27074        self.pre(&mut request, &info).await?;
27075        let result = self.exec(request, &info).await;
27076        self.post(&result, &info).await?;
27077        let response = result?;
27078        match response.status().as_u16() {
27079            200u16 => ResponseValue::from_response(response).await,
27080            400u16..=499u16 => Err(Error::ErrorResponse(
27081                ResponseValue::from_response(response).await?,
27082            )),
27083            500u16..=599u16 => Err(Error::ErrorResponse(
27084                ResponseValue::from_response(response).await?,
27085            )),
27086            _ => Err(Error::UnexpectedResponse(response)),
27087        }
27088    }
27089
27090    ///List objects
27091    ///
27092    ///Lists objects and directories for a remote path, returning the same
27093    /// fields as `rclone lsjson`.
27094    ///
27095    ///Sends a `POST` request to `/operations/list`
27096    ///
27097    ///Arguments:
27098    /// - `async_`: Run the command asynchronously. Returns a job id
27099    ///   immediately.
27100    /// - `config`: JSON encoded config overrides applied for this call only.
27101    /// - `filter`: JSON encoded filter overrides applied for this call only.
27102    /// - `group`: Assign the request to a custom stats group.
27103    /// - `dirs_only`: Set to true to return only directory entries.
27104    /// - `files_only`: Set to true to return only file entries.
27105    /// - `fs`: Remote name or path to list, for example `drive:`.
27106    /// - `hash_types`: Specify one or more hash algorithms to include when
27107    ///   `showHash` is true (e.g. `md5`).
27108    /// - `metadata`: Set to true to include backend-provided metadata maps.
27109    /// - `no_mime_type`: Set to true to omit MIME type detection.
27110    /// - `no_mod_time`: Set to true to omit modification times for faster
27111    ///   listings on some backends.
27112    /// - `opt`: Optional JSON-encoded object of listing flags (e.g. `{
27113    ///   "recurse": true, "showHash": true }`).
27114    /// - `recurse`: Set to true to list directories recursively.
27115    /// - `remote`: Directory path within `fs` to list; leave empty to target
27116    ///   the root.
27117    /// - `show_encrypted`: Set to true to include encrypted names when using
27118    ///   crypt remotes.
27119    /// - `show_hash`: Set to true to include hash digests for each entry.
27120    /// - `show_orig_i_ds`: Set to true to include original backend identifiers
27121    ///   where available.
27122    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27123    ///   instead of 200.
27124    /// - `body`
27125    pub async fn operations_list<'a>(
27126        &'a self,
27127        async_: Option<bool>,
27128        config: Option<&'a str>,
27129        filter: Option<&'a str>,
27130        group: Option<&'a str>,
27131        dirs_only: Option<bool>,
27132        files_only: Option<bool>,
27133        fs: Option<&'a str>,
27134        hash_types: Option<&'a ::std::vec::Vec<::std::string::String>>,
27135        metadata: Option<bool>,
27136        no_mime_type: Option<bool>,
27137        no_mod_time: Option<bool>,
27138        opt: Option<&'a str>,
27139        recurse: Option<bool>,
27140        remote: Option<&'a str>,
27141        show_encrypted: Option<bool>,
27142        show_hash: Option<bool>,
27143        show_orig_i_ds: Option<bool>,
27144        prefer: Option<types::OperationsListPrefer>,
27145        body: &'a types::OperationsListRequest,
27146    ) -> Result<ResponseValue<types::OperationsListResponse>, Error<types::RcError>> {
27147        let url = format!("{}/operations/list", self.baseurl,);
27148        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27149        header_map.append(
27150            ::reqwest::header::HeaderName::from_static("api-version"),
27151            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27152        );
27153        if let Some(value) = prefer {
27154            header_map.append("Prefer", value.to_string().try_into()?);
27155        }
27156
27157        #[allow(unused_mut)]
27158        let mut request = self
27159            .client
27160            .post(url)
27161            .header(
27162                ::reqwest::header::ACCEPT,
27163                ::reqwest::header::HeaderValue::from_static("application/json"),
27164            )
27165            .json(&body)
27166            .query(&progenitor_client::QueryParam::new("_async", &async_))
27167            .query(&progenitor_client::QueryParam::new("_config", &config))
27168            .query(&progenitor_client::QueryParam::new("_filter", &filter))
27169            .query(&progenitor_client::QueryParam::new("_group", &group))
27170            .query(&progenitor_client::QueryParam::new("dirsOnly", &dirs_only))
27171            .query(&progenitor_client::QueryParam::new(
27172                "filesOnly",
27173                &files_only,
27174            ))
27175            .query(&progenitor_client::QueryParam::new("fs", &fs))
27176            .query(&progenitor_client::QueryParam::new(
27177                "hashTypes",
27178                &hash_types,
27179            ))
27180            .query(&progenitor_client::QueryParam::new("metadata", &metadata))
27181            .query(&progenitor_client::QueryParam::new(
27182                "noMimeType",
27183                &no_mime_type,
27184            ))
27185            .query(&progenitor_client::QueryParam::new(
27186                "noModTime",
27187                &no_mod_time,
27188            ))
27189            .query(&progenitor_client::QueryParam::new("opt", &opt))
27190            .query(&progenitor_client::QueryParam::new("recurse", &recurse))
27191            .query(&progenitor_client::QueryParam::new("remote", &remote))
27192            .query(&progenitor_client::QueryParam::new(
27193                "showEncrypted",
27194                &show_encrypted,
27195            ))
27196            .query(&progenitor_client::QueryParam::new("showHash", &show_hash))
27197            .query(&progenitor_client::QueryParam::new(
27198                "showOrigIDs",
27199                &show_orig_i_ds,
27200            ))
27201            .headers(header_map)
27202            .build()?;
27203        let info = OperationInfo {
27204            operation_id: "operations_list",
27205        };
27206        self.pre(&mut request, &info).await?;
27207        let result = self.exec(request, &info).await;
27208        self.post(&result, &info).await?;
27209        let response = result?;
27210        match response.status().as_u16() {
27211            200u16 => ResponseValue::from_response(response).await,
27212            400u16..=499u16 => Err(Error::ErrorResponse(
27213                ResponseValue::from_response(response).await?,
27214            )),
27215            500u16..=599u16 => Err(Error::ErrorResponse(
27216                ResponseValue::from_response(response).await?,
27217            )),
27218            _ => Err(Error::UnexpectedResponse(response)),
27219        }
27220    }
27221
27222    ///Stat an object
27223    ///
27224    ///Returns metadata for a single file or directory, mirroring `rclone
27225    /// lsjson` on one entry.
27226    ///
27227    ///Sends a `POST` request to `/operations/stat`
27228    ///
27229    ///Arguments:
27230    /// - `async_`: Run the command asynchronously. Returns a job id
27231    ///   immediately.
27232    /// - `group`: Assign the request to a custom stats group.
27233    /// - `fs`: Remote name or path that contains the item to inspect.
27234    /// - `opt`: Optional JSON object of listing flags, matching those accepted
27235    ///   by `operations/list`.
27236    /// - `remote`: Path to the file or directory within `fs` to describe.
27237    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27238    ///   instead of 200.
27239    /// - `body`
27240    pub async fn operations_stat<'a>(
27241        &'a self,
27242        async_: Option<bool>,
27243        group: Option<&'a str>,
27244        fs: Option<&'a str>,
27245        opt: Option<&'a str>,
27246        remote: Option<&'a str>,
27247        prefer: Option<types::OperationsStatPrefer>,
27248        body: &'a types::OperationsStatRequest,
27249    ) -> Result<ResponseValue<types::OperationsStatResponse>, Error<types::RcError>> {
27250        let url = format!("{}/operations/stat", self.baseurl,);
27251        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27252        header_map.append(
27253            ::reqwest::header::HeaderName::from_static("api-version"),
27254            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27255        );
27256        if let Some(value) = prefer {
27257            header_map.append("Prefer", value.to_string().try_into()?);
27258        }
27259
27260        #[allow(unused_mut)]
27261        let mut request = self
27262            .client
27263            .post(url)
27264            .header(
27265                ::reqwest::header::ACCEPT,
27266                ::reqwest::header::HeaderValue::from_static("application/json"),
27267            )
27268            .json(&body)
27269            .query(&progenitor_client::QueryParam::new("_async", &async_))
27270            .query(&progenitor_client::QueryParam::new("_group", &group))
27271            .query(&progenitor_client::QueryParam::new("fs", &fs))
27272            .query(&progenitor_client::QueryParam::new("opt", &opt))
27273            .query(&progenitor_client::QueryParam::new("remote", &remote))
27274            .headers(header_map)
27275            .build()?;
27276        let info = OperationInfo {
27277            operation_id: "operations_stat",
27278        };
27279        self.pre(&mut request, &info).await?;
27280        let result = self.exec(request, &info).await;
27281        self.post(&result, &info).await?;
27282        let response = result?;
27283        match response.status().as_u16() {
27284            200u16 => ResponseValue::from_response(response).await,
27285            400u16..=499u16 => Err(Error::ErrorResponse(
27286                ResponseValue::from_response(response).await?,
27287            )),
27288            500u16..=599u16 => Err(Error::ErrorResponse(
27289                ResponseValue::from_response(response).await?,
27290            )),
27291            _ => Err(Error::UnexpectedResponse(response)),
27292        }
27293    }
27294
27295    ///Get remote quota
27296    ///
27297    ///Returns storage quota and usage details for the remote, equivalent to
27298    /// `rclone about`.
27299    ///
27300    ///Sends a `POST` request to `/operations/about`
27301    ///
27302    ///Arguments:
27303    /// - `async_`: Run the command asynchronously. Returns a job id
27304    ///   immediately.
27305    /// - `group`: Assign the request to a custom stats group.
27306    /// - `fs`: Remote name or path to query for capacity information.
27307    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27308    ///   instead of 200.
27309    /// - `body`
27310    pub async fn operations_about<'a>(
27311        &'a self,
27312        async_: Option<bool>,
27313        group: Option<&'a str>,
27314        fs: Option<&'a str>,
27315        prefer: Option<types::OperationsAboutPrefer>,
27316        body: &'a types::OperationsAboutRequest,
27317    ) -> Result<ResponseValue<types::OperationsAboutResponse>, Error<types::RcError>> {
27318        let url = format!("{}/operations/about", self.baseurl,);
27319        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27320        header_map.append(
27321            ::reqwest::header::HeaderName::from_static("api-version"),
27322            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27323        );
27324        if let Some(value) = prefer {
27325            header_map.append("Prefer", value.to_string().try_into()?);
27326        }
27327
27328        #[allow(unused_mut)]
27329        let mut request = self
27330            .client
27331            .post(url)
27332            .header(
27333                ::reqwest::header::ACCEPT,
27334                ::reqwest::header::HeaderValue::from_static("application/json"),
27335            )
27336            .json(&body)
27337            .query(&progenitor_client::QueryParam::new("_async", &async_))
27338            .query(&progenitor_client::QueryParam::new("_group", &group))
27339            .query(&progenitor_client::QueryParam::new("fs", &fs))
27340            .headers(header_map)
27341            .build()?;
27342        let info = OperationInfo {
27343            operation_id: "operations_about",
27344        };
27345        self.pre(&mut request, &info).await?;
27346        let result = self.exec(request, &info).await;
27347        self.post(&result, &info).await?;
27348        let response = result?;
27349        match response.status().as_u16() {
27350            200u16 => ResponseValue::from_response(response).await,
27351            400u16..=499u16 => Err(Error::ErrorResponse(
27352                ResponseValue::from_response(response).await?,
27353            )),
27354            500u16..=599u16 => Err(Error::ErrorResponse(
27355                ResponseValue::from_response(response).await?,
27356            )),
27357            _ => Err(Error::UnexpectedResponse(response)),
27358        }
27359    }
27360
27361    ///Upload files via multipart
27362    ///
27363    ///Accepts multipart/form-data payloads and writes the uploaded files to
27364    /// the specified remote path.
27365    ///
27366    ///Sends a `POST` request to `/operations/uploadfile`
27367    ///
27368    ///Arguments:
27369    /// - `async_`: Run the command asynchronously. Returns a job id
27370    ///   immediately.
27371    /// - `group`: Assign the request to a custom stats group.
27372    /// - `fs`: Remote name or path where the uploaded file should be stored.
27373    /// - `remote`: Destination path within `fs` for the uploaded file.
27374    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27375    ///   instead of 200.
27376    /// - `body`: Multipart form payload containing one or more files to upload.
27377    pub async fn operations_uploadfile<'a, B: Into<reqwest::Body>>(
27378        &'a self,
27379        async_: Option<bool>,
27380        group: Option<&'a str>,
27381        fs: Option<&'a str>,
27382        remote: Option<&'a str>,
27383        prefer: Option<types::OperationsUploadfilePrefer>,
27384        body: B,
27385    ) -> Result<
27386        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27387        Error<types::RcError>,
27388    > {
27389        let url = format!("{}/operations/uploadfile", self.baseurl,);
27390        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27391        header_map.append(
27392            ::reqwest::header::HeaderName::from_static("api-version"),
27393            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27394        );
27395        if let Some(value) = prefer {
27396            header_map.append("Prefer", value.to_string().try_into()?);
27397        }
27398
27399        #[allow(unused_mut)]
27400        let mut request = self
27401            .client
27402            .post(url)
27403            .header(
27404                ::reqwest::header::ACCEPT,
27405                ::reqwest::header::HeaderValue::from_static("application/json"),
27406            )
27407            .header(
27408                ::reqwest::header::CONTENT_TYPE,
27409                ::reqwest::header::HeaderValue::from_static("application/octet-stream"),
27410            )
27411            .body(body)
27412            .query(&progenitor_client::QueryParam::new("_async", &async_))
27413            .query(&progenitor_client::QueryParam::new("_group", &group))
27414            .query(&progenitor_client::QueryParam::new("fs", &fs))
27415            .query(&progenitor_client::QueryParam::new("remote", &remote))
27416            .headers(header_map)
27417            .build()?;
27418        let info = OperationInfo {
27419            operation_id: "operations_uploadfile",
27420        };
27421        self.pre(&mut request, &info).await?;
27422        let result = self.exec(request, &info).await;
27423        self.post(&result, &info).await?;
27424        let response = result?;
27425        match response.status().as_u16() {
27426            200u16 => ResponseValue::from_response(response).await,
27427            400u16..=499u16 => Err(Error::ErrorResponse(
27428                ResponseValue::from_response(response).await?,
27429            )),
27430            500u16..=599u16 => Err(Error::ErrorResponse(
27431                ResponseValue::from_response(response).await?,
27432            )),
27433            _ => Err(Error::UnexpectedResponse(response)),
27434        }
27435    }
27436
27437    ///Purge directory
27438    ///
27439    ///Deletes a directory or container and all of its contents.
27440    ///
27441    ///Sends a `POST` request to `/operations/purge`
27442    ///
27443    ///Arguments:
27444    /// - `async_`: Run the command asynchronously. Returns a job id
27445    ///   immediately.
27446    /// - `config`: JSON encoded config overrides applied for this call only.
27447    /// - `filter`: JSON encoded filter overrides applied for this call only.
27448    /// - `group`: Assign the request to a custom stats group.
27449    /// - `fs`: Remote name or path from which to remove all contents.
27450    /// - `remote`: Path within `fs` whose contents should be purged.
27451    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27452    ///   instead of 200.
27453    /// - `body`
27454    pub async fn operations_purge<'a>(
27455        &'a self,
27456        async_: Option<bool>,
27457        config: Option<&'a str>,
27458        filter: Option<&'a str>,
27459        group: Option<&'a str>,
27460        fs: Option<&'a str>,
27461        remote: Option<&'a str>,
27462        prefer: Option<types::OperationsPurgePrefer>,
27463        body: &'a types::OperationsPurgeRequest,
27464    ) -> Result<
27465        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27466        Error<types::RcError>,
27467    > {
27468        let url = format!("{}/operations/purge", self.baseurl,);
27469        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27470        header_map.append(
27471            ::reqwest::header::HeaderName::from_static("api-version"),
27472            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27473        );
27474        if let Some(value) = prefer {
27475            header_map.append("Prefer", value.to_string().try_into()?);
27476        }
27477
27478        #[allow(unused_mut)]
27479        let mut request = self
27480            .client
27481            .post(url)
27482            .header(
27483                ::reqwest::header::ACCEPT,
27484                ::reqwest::header::HeaderValue::from_static("application/json"),
27485            )
27486            .json(&body)
27487            .query(&progenitor_client::QueryParam::new("_async", &async_))
27488            .query(&progenitor_client::QueryParam::new("_config", &config))
27489            .query(&progenitor_client::QueryParam::new("_filter", &filter))
27490            .query(&progenitor_client::QueryParam::new("_group", &group))
27491            .query(&progenitor_client::QueryParam::new("fs", &fs))
27492            .query(&progenitor_client::QueryParam::new("remote", &remote))
27493            .headers(header_map)
27494            .build()?;
27495        let info = OperationInfo {
27496            operation_id: "operations_purge",
27497        };
27498        self.pre(&mut request, &info).await?;
27499        let result = self.exec(request, &info).await;
27500        self.post(&result, &info).await?;
27501        let response = result?;
27502        match response.status().as_u16() {
27503            200u16 => ResponseValue::from_response(response).await,
27504            400u16..=499u16 => Err(Error::ErrorResponse(
27505                ResponseValue::from_response(response).await?,
27506            )),
27507            500u16..=599u16 => Err(Error::ErrorResponse(
27508                ResponseValue::from_response(response).await?,
27509            )),
27510            _ => Err(Error::UnexpectedResponse(response)),
27511        }
27512    }
27513
27514    ///Create directory
27515    ///
27516    ///Creates the target directory or container if it does not exist.
27517    ///
27518    ///Sends a `POST` request to `/operations/mkdir`
27519    ///
27520    ///Arguments:
27521    /// - `async_`: Run the command asynchronously. Returns a job id
27522    ///   immediately.
27523    /// - `group`: Assign the request to a custom stats group.
27524    /// - `fs`: Remote name or path in which to create a directory.
27525    /// - `remote`: Directory path within `fs` to create.
27526    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27527    ///   instead of 200.
27528    /// - `body`
27529    pub async fn operations_mkdir<'a>(
27530        &'a self,
27531        async_: Option<bool>,
27532        group: Option<&'a str>,
27533        fs: Option<&'a str>,
27534        remote: Option<&'a str>,
27535        prefer: Option<types::OperationsMkdirPrefer>,
27536        body: &'a types::OperationsMkdirRequest,
27537    ) -> Result<
27538        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27539        Error<types::RcError>,
27540    > {
27541        let url = format!("{}/operations/mkdir", self.baseurl,);
27542        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27543        header_map.append(
27544            ::reqwest::header::HeaderName::from_static("api-version"),
27545            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27546        );
27547        if let Some(value) = prefer {
27548            header_map.append("Prefer", value.to_string().try_into()?);
27549        }
27550
27551        #[allow(unused_mut)]
27552        let mut request = self
27553            .client
27554            .post(url)
27555            .header(
27556                ::reqwest::header::ACCEPT,
27557                ::reqwest::header::HeaderValue::from_static("application/json"),
27558            )
27559            .json(&body)
27560            .query(&progenitor_client::QueryParam::new("_async", &async_))
27561            .query(&progenitor_client::QueryParam::new("_group", &group))
27562            .query(&progenitor_client::QueryParam::new("fs", &fs))
27563            .query(&progenitor_client::QueryParam::new("remote", &remote))
27564            .headers(header_map)
27565            .build()?;
27566        let info = OperationInfo {
27567            operation_id: "operations_mkdir",
27568        };
27569        self.pre(&mut request, &info).await?;
27570        let result = self.exec(request, &info).await;
27571        self.post(&result, &info).await?;
27572        let response = result?;
27573        match response.status().as_u16() {
27574            200u16 => ResponseValue::from_response(response).await,
27575            400u16..=499u16 => Err(Error::ErrorResponse(
27576                ResponseValue::from_response(response).await?,
27577            )),
27578            500u16..=599u16 => Err(Error::ErrorResponse(
27579                ResponseValue::from_response(response).await?,
27580            )),
27581            _ => Err(Error::UnexpectedResponse(response)),
27582        }
27583    }
27584
27585    ///Remove empty directory
27586    ///
27587    ///Deletes an empty directory or container.
27588    ///
27589    ///Sends a `POST` request to `/operations/rmdir`
27590    ///
27591    ///Arguments:
27592    /// - `async_`: Run the command asynchronously. Returns a job id
27593    ///   immediately.
27594    /// - `group`: Assign the request to a custom stats group.
27595    /// - `fs`: Remote name or path containing the directory to remove.
27596    /// - `remote`: Directory path within `fs` to delete.
27597    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27598    ///   instead of 200.
27599    /// - `body`
27600    pub async fn operations_rmdir<'a>(
27601        &'a self,
27602        async_: Option<bool>,
27603        group: Option<&'a str>,
27604        fs: Option<&'a str>,
27605        remote: Option<&'a str>,
27606        prefer: Option<types::OperationsRmdirPrefer>,
27607        body: &'a types::OperationsRmdirRequest,
27608    ) -> Result<
27609        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27610        Error<types::RcError>,
27611    > {
27612        let url = format!("{}/operations/rmdir", self.baseurl,);
27613        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27614        header_map.append(
27615            ::reqwest::header::HeaderName::from_static("api-version"),
27616            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27617        );
27618        if let Some(value) = prefer {
27619            header_map.append("Prefer", value.to_string().try_into()?);
27620        }
27621
27622        #[allow(unused_mut)]
27623        let mut request = self
27624            .client
27625            .post(url)
27626            .header(
27627                ::reqwest::header::ACCEPT,
27628                ::reqwest::header::HeaderValue::from_static("application/json"),
27629            )
27630            .json(&body)
27631            .query(&progenitor_client::QueryParam::new("_async", &async_))
27632            .query(&progenitor_client::QueryParam::new("_group", &group))
27633            .query(&progenitor_client::QueryParam::new("fs", &fs))
27634            .query(&progenitor_client::QueryParam::new("remote", &remote))
27635            .headers(header_map)
27636            .build()?;
27637        let info = OperationInfo {
27638            operation_id: "operations_rmdir",
27639        };
27640        self.pre(&mut request, &info).await?;
27641        let result = self.exec(request, &info).await;
27642        self.post(&result, &info).await?;
27643        let response = result?;
27644        match response.status().as_u16() {
27645            200u16 => ResponseValue::from_response(response).await,
27646            400u16..=499u16 => Err(Error::ErrorResponse(
27647                ResponseValue::from_response(response).await?,
27648            )),
27649            500u16..=599u16 => Err(Error::ErrorResponse(
27650                ResponseValue::from_response(response).await?,
27651            )),
27652            _ => Err(Error::UnexpectedResponse(response)),
27653        }
27654    }
27655
27656    ///Compare source and destination
27657    ///
27658    ///Compares source and destination trees, reporting matches, differences,
27659    /// and missing files.
27660    ///
27661    ///Sends a `POST` request to `/operations/check`
27662    ///
27663    ///Arguments:
27664    /// - `async_`: Run the command asynchronously. Returns a job id
27665    ///   immediately.
27666    /// - `group`: Assign the request to a custom stats group.
27667    /// - `check_file_fs`: Remote containing the checksum SUM file when using
27668    ///   `checkFileHash`.
27669    /// - `check_file_hash`: Hash name to expect in the supplied SUM file, such
27670    ///   as `md5`.
27671    /// - `check_file_remote`: Path within `checkFileFs` to the checksum SUM
27672    ///   file.
27673    /// - `combined`: Set to true to include a combined summary report in the
27674    ///   response.
27675    /// - `differ`: Set to true to include differing files in the report.
27676    /// - `download`: Set to true to read file contents during comparison
27677    ///   instead of relying on hashes.
27678    /// - `dst_fs`: Destination remote name or path that should match the
27679    ///   source.
27680    /// - `error`: Set to true to include entries that encountered errors.
27681    /// - `match_`: Set to true to include matching files in the report.
27682    /// - `missing_on_dst`: Set to true to report files missing from the
27683    ///   destination.
27684    /// - `missing_on_src`: Set to true to report files missing from the source.
27685    /// - `one_way`: Set to true to only ensure that source files exist on the
27686    ///   destination.
27687    /// - `src_fs`: Source remote name or path to verify, e.g. `drive:`.
27688    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27689    ///   instead of 200.
27690    /// - `body`
27691    pub async fn operations_check<'a>(
27692        &'a self,
27693        async_: Option<bool>,
27694        group: Option<&'a str>,
27695        check_file_fs: Option<&'a str>,
27696        check_file_hash: Option<&'a str>,
27697        check_file_remote: Option<&'a str>,
27698        combined: Option<bool>,
27699        differ: Option<bool>,
27700        download: Option<bool>,
27701        dst_fs: Option<&'a str>,
27702        error: Option<bool>,
27703        match_: Option<bool>,
27704        missing_on_dst: Option<bool>,
27705        missing_on_src: Option<bool>,
27706        one_way: Option<bool>,
27707        src_fs: Option<&'a str>,
27708        prefer: Option<types::OperationsCheckPrefer>,
27709        body: &'a types::OperationsCheckRequest,
27710    ) -> Result<ResponseValue<types::OperationsCheckResponse>, Error<types::RcError>> {
27711        let url = format!("{}/operations/check", self.baseurl,);
27712        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27713        header_map.append(
27714            ::reqwest::header::HeaderName::from_static("api-version"),
27715            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27716        );
27717        if let Some(value) = prefer {
27718            header_map.append("Prefer", value.to_string().try_into()?);
27719        }
27720
27721        #[allow(unused_mut)]
27722        let mut request = self
27723            .client
27724            .post(url)
27725            .header(
27726                ::reqwest::header::ACCEPT,
27727                ::reqwest::header::HeaderValue::from_static("application/json"),
27728            )
27729            .json(&body)
27730            .query(&progenitor_client::QueryParam::new("_async", &async_))
27731            .query(&progenitor_client::QueryParam::new("_group", &group))
27732            .query(&progenitor_client::QueryParam::new(
27733                "checkFileFs",
27734                &check_file_fs,
27735            ))
27736            .query(&progenitor_client::QueryParam::new(
27737                "checkFileHash",
27738                &check_file_hash,
27739            ))
27740            .query(&progenitor_client::QueryParam::new(
27741                "checkFileRemote",
27742                &check_file_remote,
27743            ))
27744            .query(&progenitor_client::QueryParam::new("combined", &combined))
27745            .query(&progenitor_client::QueryParam::new("differ", &differ))
27746            .query(&progenitor_client::QueryParam::new("download", &download))
27747            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
27748            .query(&progenitor_client::QueryParam::new("error", &error))
27749            .query(&progenitor_client::QueryParam::new("match", &match_))
27750            .query(&progenitor_client::QueryParam::new(
27751                "missingOnDst",
27752                &missing_on_dst,
27753            ))
27754            .query(&progenitor_client::QueryParam::new(
27755                "missingOnSrc",
27756                &missing_on_src,
27757            ))
27758            .query(&progenitor_client::QueryParam::new("oneWay", &one_way))
27759            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
27760            .headers(header_map)
27761            .build()?;
27762        let info = OperationInfo {
27763            operation_id: "operations_check",
27764        };
27765        self.pre(&mut request, &info).await?;
27766        let result = self.exec(request, &info).await;
27767        self.post(&result, &info).await?;
27768        let response = result?;
27769        match response.status().as_u16() {
27770            200u16 => ResponseValue::from_response(response).await,
27771            400u16..=499u16 => Err(Error::ErrorResponse(
27772                ResponseValue::from_response(response).await?,
27773            )),
27774            500u16..=599u16 => Err(Error::ErrorResponse(
27775                ResponseValue::from_response(response).await?,
27776            )),
27777            _ => Err(Error::UnexpectedResponse(response)),
27778        }
27779    }
27780
27781    ///Sync source to destination
27782    ///
27783    ///Synchronises a source remote to a destination remote, making the
27784    /// destination match the source.
27785    ///
27786    ///Sends a `POST` request to `/sync/sync`
27787    ///
27788    ///Arguments:
27789    /// - `async_`: Run the command asynchronously. Returns a job id
27790    ///   immediately.
27791    /// - `config`: JSON encoded config overrides applied for this call only.
27792    /// - `filter`: JSON encoded filter overrides applied for this call only.
27793    /// - `group`: Assign the request to a custom stats group.
27794    /// - `create_empty_src_dirs`: Set to true to create empty source
27795    ///   directories on the destination.
27796    /// - `dst_fs`: Destination remote path to sync to, e.g. `drive:dst`.
27797    /// - `src_fs`: Source remote path to sync from, e.g. `drive:src`.
27798    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27799    ///   instead of 200.
27800    /// - `body`
27801    pub async fn sync_sync<'a>(
27802        &'a self,
27803        async_: Option<bool>,
27804        config: Option<&'a str>,
27805        filter: Option<&'a str>,
27806        group: Option<&'a str>,
27807        create_empty_src_dirs: Option<bool>,
27808        dst_fs: Option<&'a str>,
27809        src_fs: Option<&'a str>,
27810        prefer: Option<types::SyncSyncPrefer>,
27811        body: &'a types::SyncSyncRequest,
27812    ) -> Result<
27813        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27814        Error<types::RcError>,
27815    > {
27816        let url = format!("{}/sync/sync", self.baseurl,);
27817        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27818        header_map.append(
27819            ::reqwest::header::HeaderName::from_static("api-version"),
27820            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27821        );
27822        if let Some(value) = prefer {
27823            header_map.append("Prefer", value.to_string().try_into()?);
27824        }
27825
27826        #[allow(unused_mut)]
27827        let mut request = self
27828            .client
27829            .post(url)
27830            .header(
27831                ::reqwest::header::ACCEPT,
27832                ::reqwest::header::HeaderValue::from_static("application/json"),
27833            )
27834            .json(&body)
27835            .query(&progenitor_client::QueryParam::new("_async", &async_))
27836            .query(&progenitor_client::QueryParam::new("_config", &config))
27837            .query(&progenitor_client::QueryParam::new("_filter", &filter))
27838            .query(&progenitor_client::QueryParam::new("_group", &group))
27839            .query(&progenitor_client::QueryParam::new(
27840                "createEmptySrcDirs",
27841                &create_empty_src_dirs,
27842            ))
27843            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
27844            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
27845            .headers(header_map)
27846            .build()?;
27847        let info = OperationInfo {
27848            operation_id: "sync_sync",
27849        };
27850        self.pre(&mut request, &info).await?;
27851        let result = self.exec(request, &info).await;
27852        self.post(&result, &info).await?;
27853        let response = result?;
27854        match response.status().as_u16() {
27855            200u16 => ResponseValue::from_response(response).await,
27856            400u16..=499u16 => Err(Error::ErrorResponse(
27857                ResponseValue::from_response(response).await?,
27858            )),
27859            500u16..=599u16 => Err(Error::ErrorResponse(
27860                ResponseValue::from_response(response).await?,
27861            )),
27862            _ => Err(Error::UnexpectedResponse(response)),
27863        }
27864    }
27865
27866    ///Copy source to destination
27867    ///
27868    ///Copies objects from a source remote to a destination remote without
27869    /// deleting destination files.
27870    ///
27871    ///Sends a `POST` request to `/sync/copy`
27872    ///
27873    ///Arguments:
27874    /// - `async_`: Run the command asynchronously. Returns a job id
27875    ///   immediately.
27876    /// - `config`: JSON encoded config overrides applied for this call only.
27877    /// - `filter`: JSON encoded filter overrides applied for this call only.
27878    /// - `group`: Assign the request to a custom stats group.
27879    /// - `create_empty_src_dirs`: Set to true to replicate empty source
27880    ///   directories on the destination.
27881    /// - `dst_fs`: Destination remote path to copy to.
27882    /// - `src_fs`: Source remote path to copy from.
27883    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27884    ///   instead of 200.
27885    /// - `body`
27886    pub async fn sync_copy<'a>(
27887        &'a self,
27888        async_: Option<bool>,
27889        config: Option<&'a str>,
27890        filter: Option<&'a str>,
27891        group: Option<&'a str>,
27892        create_empty_src_dirs: Option<bool>,
27893        dst_fs: Option<&'a str>,
27894        src_fs: Option<&'a str>,
27895        prefer: Option<types::SyncCopyPrefer>,
27896        body: &'a types::SyncCopyRequest,
27897    ) -> Result<
27898        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27899        Error<types::RcError>,
27900    > {
27901        let url = format!("{}/sync/copy", self.baseurl,);
27902        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27903        header_map.append(
27904            ::reqwest::header::HeaderName::from_static("api-version"),
27905            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27906        );
27907        if let Some(value) = prefer {
27908            header_map.append("Prefer", value.to_string().try_into()?);
27909        }
27910
27911        #[allow(unused_mut)]
27912        let mut request = self
27913            .client
27914            .post(url)
27915            .header(
27916                ::reqwest::header::ACCEPT,
27917                ::reqwest::header::HeaderValue::from_static("application/json"),
27918            )
27919            .json(&body)
27920            .query(&progenitor_client::QueryParam::new("_async", &async_))
27921            .query(&progenitor_client::QueryParam::new("_config", &config))
27922            .query(&progenitor_client::QueryParam::new("_filter", &filter))
27923            .query(&progenitor_client::QueryParam::new("_group", &group))
27924            .query(&progenitor_client::QueryParam::new(
27925                "createEmptySrcDirs",
27926                &create_empty_src_dirs,
27927            ))
27928            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
27929            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
27930            .headers(header_map)
27931            .build()?;
27932        let info = OperationInfo {
27933            operation_id: "sync_copy",
27934        };
27935        self.pre(&mut request, &info).await?;
27936        let result = self.exec(request, &info).await;
27937        self.post(&result, &info).await?;
27938        let response = result?;
27939        match response.status().as_u16() {
27940            200u16 => ResponseValue::from_response(response).await,
27941            400u16..=499u16 => Err(Error::ErrorResponse(
27942                ResponseValue::from_response(response).await?,
27943            )),
27944            500u16..=599u16 => Err(Error::ErrorResponse(
27945                ResponseValue::from_response(response).await?,
27946            )),
27947            _ => Err(Error::UnexpectedResponse(response)),
27948        }
27949    }
27950
27951    ///Move source to destination
27952    ///
27953    ///Moves objects from a source remote to a destination remote, optionally
27954    /// cleaning up empty directories.
27955    ///
27956    ///Sends a `POST` request to `/sync/move`
27957    ///
27958    ///Arguments:
27959    /// - `async_`: Run the command asynchronously. Returns a job id
27960    ///   immediately.
27961    /// - `config`: JSON encoded config overrides applied for this call only.
27962    /// - `filter`: JSON encoded filter overrides applied for this call only.
27963    /// - `group`: Assign the request to a custom stats group.
27964    /// - `create_empty_src_dirs`: Set to true to create empty source
27965    ///   directories on the destination.
27966    /// - `delete_empty_src_dirs`: Set to true to delete empty directories from
27967    ///   the source after the move completes.
27968    /// - `dst_fs`: Destination remote path that will receive moved files.
27969    /// - `src_fs`: Source remote path whose contents will be moved.
27970    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
27971    ///   instead of 200.
27972    /// - `body`
27973    pub async fn sync_move<'a>(
27974        &'a self,
27975        async_: Option<bool>,
27976        config: Option<&'a str>,
27977        filter: Option<&'a str>,
27978        group: Option<&'a str>,
27979        create_empty_src_dirs: Option<bool>,
27980        delete_empty_src_dirs: Option<bool>,
27981        dst_fs: Option<&'a str>,
27982        src_fs: Option<&'a str>,
27983        prefer: Option<types::SyncMovePrefer>,
27984        body: &'a types::SyncMoveRequest,
27985    ) -> Result<
27986        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
27987        Error<types::RcError>,
27988    > {
27989        let url = format!("{}/sync/move", self.baseurl,);
27990        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
27991        header_map.append(
27992            ::reqwest::header::HeaderName::from_static("api-version"),
27993            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
27994        );
27995        if let Some(value) = prefer {
27996            header_map.append("Prefer", value.to_string().try_into()?);
27997        }
27998
27999        #[allow(unused_mut)]
28000        let mut request = self
28001            .client
28002            .post(url)
28003            .header(
28004                ::reqwest::header::ACCEPT,
28005                ::reqwest::header::HeaderValue::from_static("application/json"),
28006            )
28007            .json(&body)
28008            .query(&progenitor_client::QueryParam::new("_async", &async_))
28009            .query(&progenitor_client::QueryParam::new("_config", &config))
28010            .query(&progenitor_client::QueryParam::new("_filter", &filter))
28011            .query(&progenitor_client::QueryParam::new("_group", &group))
28012            .query(&progenitor_client::QueryParam::new(
28013                "createEmptySrcDirs",
28014                &create_empty_src_dirs,
28015            ))
28016            .query(&progenitor_client::QueryParam::new(
28017                "deleteEmptySrcDirs",
28018                &delete_empty_src_dirs,
28019            ))
28020            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
28021            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
28022            .headers(header_map)
28023            .build()?;
28024        let info = OperationInfo {
28025            operation_id: "sync_move",
28026        };
28027        self.pre(&mut request, &info).await?;
28028        let result = self.exec(request, &info).await;
28029        self.post(&result, &info).await?;
28030        let response = result?;
28031        match response.status().as_u16() {
28032            200u16 => ResponseValue::from_response(response).await,
28033            400u16..=499u16 => Err(Error::ErrorResponse(
28034                ResponseValue::from_response(response).await?,
28035            )),
28036            500u16..=599u16 => Err(Error::ErrorResponse(
28037                ResponseValue::from_response(response).await?,
28038            )),
28039            _ => Err(Error::UnexpectedResponse(response)),
28040        }
28041    }
28042
28043    ///Bidirectional sync
28044    ///
28045    ///Performs a bidirectional synchronisation between two paths, supporting
28046    /// safety checks and recovery options.
28047    ///
28048    ///Sends a `POST` request to `/sync/bisync`
28049    ///
28050    ///Arguments:
28051    /// - `async_`: Run the command asynchronously. Returns a job id
28052    ///   immediately.
28053    /// - `config`: JSON encoded config overrides applied for this call only.
28054    /// - `filter`: JSON encoded filter overrides applied for this call only.
28055    /// - `group`: Assign the request to a custom stats group.
28056    /// - `backupdir1`: Backup directory on the first remote for changed files.
28057    /// - `backupdir2`: Backup directory on the second remote for changed files.
28058    /// - `check_access`: Set to true to abort if `RCLONE_TEST` files are
28059    ///   missing on either side.
28060    /// - `check_filename`: Override the access-check sentinel filename;
28061    ///   defaults to `RCLONE_TEST`.
28062    /// - `check_sync`: Controls final listing comparison; leave true for normal
28063    ///   verification or set false to skip.
28064    /// - `create_empty_src_dirs`: Set to true to mirror empty directories
28065    ///   between the two paths.
28066    /// - `dry_run`: Set to true to simulate the bisync run without making
28067    ///   changes.
28068    /// - `filters_file`: Path to an rclone filters file applied to both paths.
28069    /// - `force`: Set to true to bypass the `maxDelete` safety check.
28070    /// - `ignore_listing_checksum`: Set to true to ignore checksum differences
28071    ///   when comparing listings.
28072    /// - `max_delete`: Abort the run if deletions exceed this percentage
28073    ///   (default 50).
28074    /// - `no_cleanup`: Set to true to keep bisync working files after
28075    ///   completion.
28076    /// - `path1`: First remote directory, e.g. `drive:path1`.
28077    /// - `path2`: Second remote directory, e.g. `drive:path2`.
28078    /// - `remove_empty_dirs`: Set to true to remove empty directories during
28079    ///   cleanup.
28080    /// - `resilient`: Set to true to allow retrying after certain recoverable
28081    ///   errors.
28082    /// - `resync`: Set to true to perform a one-time resync, rebuilding bisync
28083    ///   history.
28084    /// - `workdir`: Directory path used to store bisync working files.
28085    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28086    ///   instead of 200.
28087    /// - `body`
28088    pub async fn sync_bisync<'a>(
28089        &'a self,
28090        async_: Option<bool>,
28091        config: Option<&'a str>,
28092        filter: Option<&'a str>,
28093        group: Option<&'a str>,
28094        backupdir1: Option<&'a str>,
28095        backupdir2: Option<&'a str>,
28096        check_access: Option<bool>,
28097        check_filename: Option<&'a str>,
28098        check_sync: Option<bool>,
28099        create_empty_src_dirs: Option<bool>,
28100        dry_run: Option<bool>,
28101        filters_file: Option<&'a str>,
28102        force: Option<bool>,
28103        ignore_listing_checksum: Option<bool>,
28104        max_delete: Option<f64>,
28105        no_cleanup: Option<bool>,
28106        path1: Option<&'a str>,
28107        path2: Option<&'a str>,
28108        remove_empty_dirs: Option<bool>,
28109        resilient: Option<bool>,
28110        resync: Option<bool>,
28111        workdir: Option<&'a str>,
28112        prefer: Option<types::SyncBisyncPrefer>,
28113        body: &'a types::SyncBisyncRequest,
28114    ) -> Result<ResponseValue<types::SyncBisyncResponse>, Error<types::RcError>> {
28115        let url = format!("{}/sync/bisync", self.baseurl,);
28116        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28117        header_map.append(
28118            ::reqwest::header::HeaderName::from_static("api-version"),
28119            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28120        );
28121        if let Some(value) = prefer {
28122            header_map.append("Prefer", value.to_string().try_into()?);
28123        }
28124
28125        #[allow(unused_mut)]
28126        let mut request = self
28127            .client
28128            .post(url)
28129            .header(
28130                ::reqwest::header::ACCEPT,
28131                ::reqwest::header::HeaderValue::from_static("application/json"),
28132            )
28133            .json(&body)
28134            .query(&progenitor_client::QueryParam::new("_async", &async_))
28135            .query(&progenitor_client::QueryParam::new("_config", &config))
28136            .query(&progenitor_client::QueryParam::new("_filter", &filter))
28137            .query(&progenitor_client::QueryParam::new("_group", &group))
28138            .query(&progenitor_client::QueryParam::new(
28139                "backupdir1",
28140                &backupdir1,
28141            ))
28142            .query(&progenitor_client::QueryParam::new(
28143                "backupdir2",
28144                &backupdir2,
28145            ))
28146            .query(&progenitor_client::QueryParam::new(
28147                "checkAccess",
28148                &check_access,
28149            ))
28150            .query(&progenitor_client::QueryParam::new(
28151                "checkFilename",
28152                &check_filename,
28153            ))
28154            .query(&progenitor_client::QueryParam::new(
28155                "checkSync",
28156                &check_sync,
28157            ))
28158            .query(&progenitor_client::QueryParam::new(
28159                "createEmptySrcDirs",
28160                &create_empty_src_dirs,
28161            ))
28162            .query(&progenitor_client::QueryParam::new("dryRun", &dry_run))
28163            .query(&progenitor_client::QueryParam::new(
28164                "filtersFile",
28165                &filters_file,
28166            ))
28167            .query(&progenitor_client::QueryParam::new("force", &force))
28168            .query(&progenitor_client::QueryParam::new(
28169                "ignoreListingChecksum",
28170                &ignore_listing_checksum,
28171            ))
28172            .query(&progenitor_client::QueryParam::new(
28173                "maxDelete",
28174                &max_delete,
28175            ))
28176            .query(&progenitor_client::QueryParam::new(
28177                "noCleanup",
28178                &no_cleanup,
28179            ))
28180            .query(&progenitor_client::QueryParam::new("path1", &path1))
28181            .query(&progenitor_client::QueryParam::new("path2", &path2))
28182            .query(&progenitor_client::QueryParam::new(
28183                "removeEmptyDirs",
28184                &remove_empty_dirs,
28185            ))
28186            .query(&progenitor_client::QueryParam::new("resilient", &resilient))
28187            .query(&progenitor_client::QueryParam::new("resync", &resync))
28188            .query(&progenitor_client::QueryParam::new("workdir", &workdir))
28189            .headers(header_map)
28190            .build()?;
28191        let info = OperationInfo {
28192            operation_id: "sync_bisync",
28193        };
28194        self.pre(&mut request, &info).await?;
28195        let result = self.exec(request, &info).await;
28196        self.post(&result, &info).await?;
28197        let response = result?;
28198        match response.status().as_u16() {
28199            200u16 => ResponseValue::from_response(response).await,
28200            400u16..=499u16 => Err(Error::ErrorResponse(
28201                ResponseValue::from_response(response).await?,
28202            )),
28203            500u16..=599u16 => Err(Error::ErrorResponse(
28204                ResponseValue::from_response(response).await?,
28205            )),
28206            _ => Err(Error::UnexpectedResponse(response)),
28207        }
28208    }
28209
28210    ///List option blocks
28211    ///
28212    ///Returns the names of option blocks that can be queried or updated.
28213    ///
28214    ///Sends a `POST` request to `/options/blocks`
28215    ///
28216    ///Arguments:
28217    /// - `async_`: Run the command asynchronously. Returns a job id
28218    ///   immediately.
28219    /// - `group`: Assign the request to a custom stats group.
28220    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28221    ///   instead of 200.
28222    /// - `body`
28223    pub async fn options_blocks<'a>(
28224        &'a self,
28225        async_: Option<bool>,
28226        group: Option<&'a str>,
28227        prefer: Option<types::OptionsBlocksPrefer>,
28228        body: &'a types::OptionsBlocksRequest,
28229    ) -> Result<ResponseValue<types::OptionsBlocksResponse>, Error<types::RcError>> {
28230        let url = format!("{}/options/blocks", self.baseurl,);
28231        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28232        header_map.append(
28233            ::reqwest::header::HeaderName::from_static("api-version"),
28234            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28235        );
28236        if let Some(value) = prefer {
28237            header_map.append("Prefer", value.to_string().try_into()?);
28238        }
28239
28240        #[allow(unused_mut)]
28241        let mut request = self
28242            .client
28243            .post(url)
28244            .header(
28245                ::reqwest::header::ACCEPT,
28246                ::reqwest::header::HeaderValue::from_static("application/json"),
28247            )
28248            .json(&body)
28249            .query(&progenitor_client::QueryParam::new("_async", &async_))
28250            .query(&progenitor_client::QueryParam::new("_group", &group))
28251            .headers(header_map)
28252            .build()?;
28253        let info = OperationInfo {
28254            operation_id: "options_blocks",
28255        };
28256        self.pre(&mut request, &info).await?;
28257        let result = self.exec(request, &info).await;
28258        self.post(&result, &info).await?;
28259        let response = result?;
28260        match response.status().as_u16() {
28261            200u16 => ResponseValue::from_response(response).await,
28262            400u16..=499u16 => Err(Error::ErrorResponse(
28263                ResponseValue::from_response(response).await?,
28264            )),
28265            500u16..=599u16 => Err(Error::ErrorResponse(
28266                ResponseValue::from_response(response).await?,
28267            )),
28268            _ => Err(Error::UnexpectedResponse(response)),
28269        }
28270    }
28271
28272    ///Get option values
28273    ///
28274    ///Returns the current global option values, optionally filtered by block.
28275    ///
28276    ///Sends a `POST` request to `/options/get`
28277    ///
28278    ///Arguments:
28279    /// - `async_`: Run the command asynchronously. Returns a job id
28280    ///   immediately.
28281    /// - `group`: Assign the request to a custom stats group.
28282    /// - `blocks`: Optional comma-separated list of option block names to
28283    ///   return.
28284    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28285    ///   instead of 200.
28286    /// - `body`
28287    pub async fn options_get<'a>(
28288        &'a self,
28289        async_: Option<bool>,
28290        group: Option<&'a str>,
28291        blocks: Option<&'a str>,
28292        prefer: Option<types::OptionsGetPrefer>,
28293        body: &'a types::OptionsGetRequest,
28294    ) -> Result<ResponseValue<types::OptionsGetResponse>, Error<types::RcError>> {
28295        let url = format!("{}/options/get", self.baseurl,);
28296        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28297        header_map.append(
28298            ::reqwest::header::HeaderName::from_static("api-version"),
28299            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28300        );
28301        if let Some(value) = prefer {
28302            header_map.append("Prefer", value.to_string().try_into()?);
28303        }
28304
28305        #[allow(unused_mut)]
28306        let mut request = self
28307            .client
28308            .post(url)
28309            .header(
28310                ::reqwest::header::ACCEPT,
28311                ::reqwest::header::HeaderValue::from_static("application/json"),
28312            )
28313            .json(&body)
28314            .query(&progenitor_client::QueryParam::new("_async", &async_))
28315            .query(&progenitor_client::QueryParam::new("_group", &group))
28316            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
28317            .headers(header_map)
28318            .build()?;
28319        let info = OperationInfo {
28320            operation_id: "options_get",
28321        };
28322        self.pre(&mut request, &info).await?;
28323        let result = self.exec(request, &info).await;
28324        self.post(&result, &info).await?;
28325        let response = result?;
28326        match response.status().as_u16() {
28327            200u16 => ResponseValue::from_response(response).await,
28328            400u16..=499u16 => Err(Error::ErrorResponse(
28329                ResponseValue::from_response(response).await?,
28330            )),
28331            500u16..=599u16 => Err(Error::ErrorResponse(
28332                ResponseValue::from_response(response).await?,
28333            )),
28334            _ => Err(Error::UnexpectedResponse(response)),
28335        }
28336    }
28337
28338    ///Describe options
28339    ///
28340    ///Returns metadata for options, including help text and defaults, grouped
28341    /// by block.
28342    ///
28343    ///Sends a `POST` request to `/options/info`
28344    ///
28345    ///Arguments:
28346    /// - `async_`: Run the command asynchronously. Returns a job id
28347    ///   immediately.
28348    /// - `group`: Assign the request to a custom stats group.
28349    /// - `blocks`: Optional comma-separated list of option block names to
28350    ///   describe.
28351    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28352    ///   instead of 200.
28353    /// - `body`
28354    pub async fn options_info<'a>(
28355        &'a self,
28356        async_: Option<bool>,
28357        group: Option<&'a str>,
28358        blocks: Option<&'a str>,
28359        prefer: Option<types::OptionsInfoPrefer>,
28360        body: &'a types::OptionsInfoRequest,
28361    ) -> Result<ResponseValue<types::OptionsInfoResponse>, Error<types::RcError>> {
28362        let url = format!("{}/options/info", self.baseurl,);
28363        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28364        header_map.append(
28365            ::reqwest::header::HeaderName::from_static("api-version"),
28366            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28367        );
28368        if let Some(value) = prefer {
28369            header_map.append("Prefer", value.to_string().try_into()?);
28370        }
28371
28372        #[allow(unused_mut)]
28373        let mut request = self
28374            .client
28375            .post(url)
28376            .header(
28377                ::reqwest::header::ACCEPT,
28378                ::reqwest::header::HeaderValue::from_static("application/json"),
28379            )
28380            .json(&body)
28381            .query(&progenitor_client::QueryParam::new("_async", &async_))
28382            .query(&progenitor_client::QueryParam::new("_group", &group))
28383            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
28384            .headers(header_map)
28385            .build()?;
28386        let info = OperationInfo {
28387            operation_id: "options_info",
28388        };
28389        self.pre(&mut request, &info).await?;
28390        let result = self.exec(request, &info).await;
28391        self.post(&result, &info).await?;
28392        let response = result?;
28393        match response.status().as_u16() {
28394            200u16 => ResponseValue::from_response(response).await,
28395            400u16..=499u16 => Err(Error::ErrorResponse(
28396                ResponseValue::from_response(response).await?,
28397            )),
28398            500u16..=599u16 => Err(Error::ErrorResponse(
28399                ResponseValue::from_response(response).await?,
28400            )),
28401            _ => Err(Error::UnexpectedResponse(response)),
28402        }
28403    }
28404
28405    ///Set option values
28406    ///
28407    ///Sets temporary option overrides for the running process by supplying
28408    /// key/value pairs grouped under option block names. Provide one or more
28409    /// query parameters whose names match the blocks you want to modify (for
28410    /// example `main`, `rc`, `http`). Each block parameter carries an object of
28411    /// option overrides.
28412    ///
28413    ///
28414    ///Sends a `POST` request to `/options/set`
28415    ///
28416    ///Arguments:
28417    /// - `async_`: Run the command asynchronously. Returns a job id
28418    ///   immediately.
28419    /// - `group`: Assign the request to a custom stats group.
28420    /// - `dlna`: Overrides for the `dlna` option block.
28421    /// - `filter`: Overrides for the `filter` option block.
28422    /// - `ftp`: Overrides for the `ftp` option block.
28423    /// - `http`: Overrides for the `http` option block.
28424    /// - `log`: Overrides for the `log` option block.
28425    /// - `main`: Overrides for the `main` option block.
28426    /// - `mount`: Overrides for the `mount` option block.
28427    /// - `nfs`: Overrides for the `nfs` option block.
28428    /// - `proxy`: Overrides for the `proxy` option block.
28429    /// - `rc`: Overrides for the `rc` option block.
28430    /// - `restic`: Overrides for the `restic` option block.
28431    /// - `s3`: Overrides for the `s3` option block.
28432    /// - `sftp`: Overrides for the `sftp` option block.
28433    /// - `vfs`: Overrides for the `vfs` option block.
28434    /// - `webdav`: Overrides for the `webdav` option block.
28435    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28436    ///   instead of 200.
28437    /// - `body`
28438    pub async fn options_set<'a>(
28439        &'a self,
28440        async_: Option<bool>,
28441        group: Option<&'a str>,
28442        dlna: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28443        filter: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28444        ftp: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28445        http: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28446        log: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28447        main: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28448        mount: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28449        nfs: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28450        proxy: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28451        rc: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28452        restic: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28453        s3: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28454        sftp: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28455        vfs: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28456        webdav: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28457        prefer: Option<types::OptionsSetPrefer>,
28458        body: &'a types::OptionsSetRequest,
28459    ) -> Result<
28460        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28461        Error<types::RcError>,
28462    > {
28463        let url = format!("{}/options/set", self.baseurl,);
28464        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28465        header_map.append(
28466            ::reqwest::header::HeaderName::from_static("api-version"),
28467            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28468        );
28469        if let Some(value) = prefer {
28470            header_map.append("Prefer", value.to_string().try_into()?);
28471        }
28472
28473        #[allow(unused_mut)]
28474        let mut request = self
28475            .client
28476            .post(url)
28477            .header(
28478                ::reqwest::header::ACCEPT,
28479                ::reqwest::header::HeaderValue::from_static("application/json"),
28480            )
28481            .json(&body)
28482            .query(&progenitor_client::QueryParam::new("_async", &async_))
28483            .query(&progenitor_client::QueryParam::new("_group", &group))
28484            .query(&progenitor_client::QueryParam::new("dlna", &dlna))
28485            .query(&progenitor_client::QueryParam::new("filter", &filter))
28486            .query(&progenitor_client::QueryParam::new("ftp", &ftp))
28487            .query(&progenitor_client::QueryParam::new("http", &http))
28488            .query(&progenitor_client::QueryParam::new("log", &log))
28489            .query(&progenitor_client::QueryParam::new("main", &main))
28490            .query(&progenitor_client::QueryParam::new("mount", &mount))
28491            .query(&progenitor_client::QueryParam::new("nfs", &nfs))
28492            .query(&progenitor_client::QueryParam::new("proxy", &proxy))
28493            .query(&progenitor_client::QueryParam::new("rc", &rc))
28494            .query(&progenitor_client::QueryParam::new("restic", &restic))
28495            .query(&progenitor_client::QueryParam::new("s3", &s3))
28496            .query(&progenitor_client::QueryParam::new("sftp", &sftp))
28497            .query(&progenitor_client::QueryParam::new("vfs", &vfs))
28498            .query(&progenitor_client::QueryParam::new("webdav", &webdav))
28499            .headers(header_map)
28500            .build()?;
28501        let info = OperationInfo {
28502            operation_id: "options_set",
28503        };
28504        self.pre(&mut request, &info).await?;
28505        let result = self.exec(request, &info).await;
28506        self.post(&result, &info).await?;
28507        let response = result?;
28508        match response.status().as_u16() {
28509            200u16 => ResponseValue::from_response(response).await,
28510            400u16..=499u16 => Err(Error::ErrorResponse(
28511                ResponseValue::from_response(response).await?,
28512            )),
28513            500u16..=599u16 => Err(Error::ErrorResponse(
28514                ResponseValue::from_response(response).await?,
28515            )),
28516            _ => Err(Error::UnexpectedResponse(response)),
28517        }
28518    }
28519
28520    ///Show effective options
28521    ///
28522    ///Returns the current effective options for this request, including
28523    /// `_config` and `_filter` overrides.
28524    ///
28525    ///Sends a `POST` request to `/options/local`
28526    ///
28527    ///Arguments:
28528    /// - `async_`: Run the command asynchronously. Returns a job id
28529    ///   immediately.
28530    /// - `config`: JSON encoded config overrides applied for this call only.
28531    /// - `filter`: JSON encoded filter overrides applied for this call only.
28532    /// - `group`: Assign the request to a custom stats group.
28533    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28534    ///   instead of 200.
28535    /// - `body`
28536    pub async fn options_local<'a>(
28537        &'a self,
28538        async_: Option<bool>,
28539        config: Option<&'a str>,
28540        filter: Option<&'a str>,
28541        group: Option<&'a str>,
28542        prefer: Option<types::OptionsLocalPrefer>,
28543        body: &'a types::OptionsLocalRequest,
28544    ) -> Result<ResponseValue<types::OptionsLocalResponse>, Error<types::RcError>> {
28545        let url = format!("{}/options/local", self.baseurl,);
28546        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28547        header_map.append(
28548            ::reqwest::header::HeaderName::from_static("api-version"),
28549            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28550        );
28551        if let Some(value) = prefer {
28552            header_map.append("Prefer", value.to_string().try_into()?);
28553        }
28554
28555        #[allow(unused_mut)]
28556        let mut request = self
28557            .client
28558            .post(url)
28559            .header(
28560                ::reqwest::header::ACCEPT,
28561                ::reqwest::header::HeaderValue::from_static("application/json"),
28562            )
28563            .json(&body)
28564            .query(&progenitor_client::QueryParam::new("_async", &async_))
28565            .query(&progenitor_client::QueryParam::new("_config", &config))
28566            .query(&progenitor_client::QueryParam::new("_filter", &filter))
28567            .query(&progenitor_client::QueryParam::new("_group", &group))
28568            .headers(header_map)
28569            .build()?;
28570        let info = OperationInfo {
28571            operation_id: "options_local",
28572        };
28573        self.pre(&mut request, &info).await?;
28574        let result = self.exec(request, &info).await;
28575        self.post(&result, &info).await?;
28576        let response = result?;
28577        match response.status().as_u16() {
28578            200u16 => ResponseValue::from_response(response).await,
28579            400u16..=499u16 => Err(Error::ErrorResponse(
28580                ResponseValue::from_response(response).await?,
28581            )),
28582            500u16..=599u16 => Err(Error::ErrorResponse(
28583                ResponseValue::from_response(response).await?,
28584            )),
28585            _ => Err(Error::UnexpectedResponse(response)),
28586        }
28587    }
28588
28589    ///List serve instances
28590    ///
28591    ///Returns all running `rclone serve` instances with their IDs and options.
28592    ///
28593    ///Sends a `POST` request to `/serve/list`
28594    ///
28595    ///Arguments:
28596    /// - `async_`: Run the command asynchronously. Returns a job id
28597    ///   immediately.
28598    /// - `group`: Assign the request to a custom stats group.
28599    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28600    ///   instead of 200.
28601    /// - `body`
28602    pub async fn serve_list<'a>(
28603        &'a self,
28604        async_: Option<bool>,
28605        group: Option<&'a str>,
28606        prefer: Option<types::ServeListPrefer>,
28607        body: &'a types::ServeListRequest,
28608    ) -> Result<ResponseValue<types::ServeListResponse>, Error<types::RcError>> {
28609        let url = format!("{}/serve/list", self.baseurl,);
28610        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28611        header_map.append(
28612            ::reqwest::header::HeaderName::from_static("api-version"),
28613            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28614        );
28615        if let Some(value) = prefer {
28616            header_map.append("Prefer", value.to_string().try_into()?);
28617        }
28618
28619        #[allow(unused_mut)]
28620        let mut request = self
28621            .client
28622            .post(url)
28623            .header(
28624                ::reqwest::header::ACCEPT,
28625                ::reqwest::header::HeaderValue::from_static("application/json"),
28626            )
28627            .json(&body)
28628            .query(&progenitor_client::QueryParam::new("_async", &async_))
28629            .query(&progenitor_client::QueryParam::new("_group", &group))
28630            .headers(header_map)
28631            .build()?;
28632        let info = OperationInfo {
28633            operation_id: "serve_list",
28634        };
28635        self.pre(&mut request, &info).await?;
28636        let result = self.exec(request, &info).await;
28637        self.post(&result, &info).await?;
28638        let response = result?;
28639        match response.status().as_u16() {
28640            200u16 => ResponseValue::from_response(response).await,
28641            400u16..=499u16 => Err(Error::ErrorResponse(
28642                ResponseValue::from_response(response).await?,
28643            )),
28644            500u16..=599u16 => Err(Error::ErrorResponse(
28645                ResponseValue::from_response(response).await?,
28646            )),
28647            _ => Err(Error::UnexpectedResponse(response)),
28648        }
28649    }
28650
28651    ///Start serve instance
28652    ///
28653    ///Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with
28654    /// the provided parameters.
28655    ///
28656    ///Sends a `POST` request to `/serve/start`
28657    ///
28658    ///Arguments:
28659    /// - `async_`: Run the command asynchronously. Returns a job id
28660    ///   immediately.
28661    /// - `config`: JSON encoded config overrides applied for this call only.
28662    /// - `filter`: JSON encoded filter overrides applied for this call only.
28663    /// - `group`: Assign the request to a custom stats group.
28664    /// - `addr`: Address and port to bind the server to, such as `:5572` or
28665    ///   `localhost:8080`.
28666    /// - `fs`: Remote path that will be served.
28667    /// - `params`: Additional arbitrary parameters allowed.
28668    /// - `type_`: Type of server to start (e.g. `http`, `webdav`, `ftp`,
28669    ///   `sftp`).
28670    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28671    ///   instead of 200.
28672    /// - `body`
28673    pub async fn serve_start<'a>(
28674        &'a self,
28675        async_: Option<bool>,
28676        config: Option<&'a str>,
28677        filter: Option<&'a str>,
28678        group: Option<&'a str>,
28679        addr: Option<&'a str>,
28680        fs: Option<&'a str>,
28681        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28682        type_: Option<&'a str>,
28683        prefer: Option<types::ServeStartPrefer>,
28684        body: &'a types::ServeStartRequest,
28685    ) -> Result<ResponseValue<types::ServeStartResponse>, Error<types::RcError>> {
28686        let url = format!("{}/serve/start", self.baseurl,);
28687        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28688        header_map.append(
28689            ::reqwest::header::HeaderName::from_static("api-version"),
28690            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28691        );
28692        if let Some(value) = prefer {
28693            header_map.append("Prefer", value.to_string().try_into()?);
28694        }
28695
28696        #[allow(unused_mut)]
28697        let mut request = self
28698            .client
28699            .post(url)
28700            .header(
28701                ::reqwest::header::ACCEPT,
28702                ::reqwest::header::HeaderValue::from_static("application/json"),
28703            )
28704            .json(&body)
28705            .query(&progenitor_client::QueryParam::new("_async", &async_))
28706            .query(&progenitor_client::QueryParam::new("_config", &config))
28707            .query(&progenitor_client::QueryParam::new("_filter", &filter))
28708            .query(&progenitor_client::QueryParam::new("_group", &group))
28709            .query(&progenitor_client::QueryParam::new("addr", &addr))
28710            .query(&progenitor_client::QueryParam::new("fs", &fs))
28711            .query(&progenitor_client::QueryParam::new("params", &params))
28712            .query(&progenitor_client::QueryParam::new("type", &type_))
28713            .headers(header_map)
28714            .build()?;
28715        let info = OperationInfo {
28716            operation_id: "serve_start",
28717        };
28718        self.pre(&mut request, &info).await?;
28719        let result = self.exec(request, &info).await;
28720        self.post(&result, &info).await?;
28721        let response = result?;
28722        match response.status().as_u16() {
28723            200u16 => ResponseValue::from_response(response).await,
28724            400u16..=499u16 => Err(Error::ErrorResponse(
28725                ResponseValue::from_response(response).await?,
28726            )),
28727            500u16..=599u16 => Err(Error::ErrorResponse(
28728                ResponseValue::from_response(response).await?,
28729            )),
28730            _ => Err(Error::UnexpectedResponse(response)),
28731        }
28732    }
28733
28734    ///Stop serve instance
28735    ///
28736    ///Stops a running `serve` instance identified by its ID.
28737    ///
28738    ///Sends a `POST` request to `/serve/stop`
28739    ///
28740    ///Arguments:
28741    /// - `async_`: Run the command asynchronously. Returns a job id
28742    ///   immediately.
28743    /// - `group`: Assign the request to a custom stats group.
28744    /// - `id`: Identifier of the running serve instance returned by
28745    ///   `serve/start`.
28746    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28747    ///   instead of 200.
28748    /// - `body`
28749    pub async fn serve_stop<'a>(
28750        &'a self,
28751        async_: Option<bool>,
28752        group: Option<&'a str>,
28753        id: Option<&'a str>,
28754        prefer: Option<types::ServeStopPrefer>,
28755        body: &'a types::ServeStopRequest,
28756    ) -> Result<
28757        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28758        Error<types::RcError>,
28759    > {
28760        let url = format!("{}/serve/stop", self.baseurl,);
28761        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28762        header_map.append(
28763            ::reqwest::header::HeaderName::from_static("api-version"),
28764            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28765        );
28766        if let Some(value) = prefer {
28767            header_map.append("Prefer", value.to_string().try_into()?);
28768        }
28769
28770        #[allow(unused_mut)]
28771        let mut request = self
28772            .client
28773            .post(url)
28774            .header(
28775                ::reqwest::header::ACCEPT,
28776                ::reqwest::header::HeaderValue::from_static("application/json"),
28777            )
28778            .json(&body)
28779            .query(&progenitor_client::QueryParam::new("_async", &async_))
28780            .query(&progenitor_client::QueryParam::new("_group", &group))
28781            .query(&progenitor_client::QueryParam::new("id", &id))
28782            .headers(header_map)
28783            .build()?;
28784        let info = OperationInfo {
28785            operation_id: "serve_stop",
28786        };
28787        self.pre(&mut request, &info).await?;
28788        let result = self.exec(request, &info).await;
28789        self.post(&result, &info).await?;
28790        let response = result?;
28791        match response.status().as_u16() {
28792            200u16 => ResponseValue::from_response(response).await,
28793            400u16..=499u16 => Err(Error::ErrorResponse(
28794                ResponseValue::from_response(response).await?,
28795            )),
28796            500u16..=599u16 => Err(Error::ErrorResponse(
28797                ResponseValue::from_response(response).await?,
28798            )),
28799            _ => Err(Error::UnexpectedResponse(response)),
28800        }
28801    }
28802
28803    ///Stop all serve instances
28804    ///
28805    ///Stops every active `serve` instance.
28806    ///
28807    ///Sends a `POST` request to `/serve/stopall`
28808    ///
28809    ///Arguments:
28810    /// - `async_`: Run the command asynchronously. Returns a job id
28811    ///   immediately.
28812    /// - `group`: Assign the request to a custom stats group.
28813    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28814    ///   instead of 200.
28815    /// - `body`
28816    pub async fn serve_stopall<'a>(
28817        &'a self,
28818        async_: Option<bool>,
28819        group: Option<&'a str>,
28820        prefer: Option<types::ServeStopallPrefer>,
28821        body: &'a types::ServeStopallRequest,
28822    ) -> Result<
28823        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28824        Error<types::RcError>,
28825    > {
28826        let url = format!("{}/serve/stopall", self.baseurl,);
28827        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28828        header_map.append(
28829            ::reqwest::header::HeaderName::from_static("api-version"),
28830            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28831        );
28832        if let Some(value) = prefer {
28833            header_map.append("Prefer", value.to_string().try_into()?);
28834        }
28835
28836        #[allow(unused_mut)]
28837        let mut request = self
28838            .client
28839            .post(url)
28840            .header(
28841                ::reqwest::header::ACCEPT,
28842                ::reqwest::header::HeaderValue::from_static("application/json"),
28843            )
28844            .json(&body)
28845            .query(&progenitor_client::QueryParam::new("_async", &async_))
28846            .query(&progenitor_client::QueryParam::new("_group", &group))
28847            .headers(header_map)
28848            .build()?;
28849        let info = OperationInfo {
28850            operation_id: "serve_stopall",
28851        };
28852        self.pre(&mut request, &info).await?;
28853        let result = self.exec(request, &info).await;
28854        self.post(&result, &info).await?;
28855        let response = result?;
28856        match response.status().as_u16() {
28857            200u16 => ResponseValue::from_response(response).await,
28858            400u16..=499u16 => Err(Error::ErrorResponse(
28859                ResponseValue::from_response(response).await?,
28860            )),
28861            500u16..=599u16 => Err(Error::ErrorResponse(
28862                ResponseValue::from_response(response).await?,
28863            )),
28864            _ => Err(Error::UnexpectedResponse(response)),
28865        }
28866    }
28867
28868    ///List serve types
28869    ///
28870    ///Returns the list of supported `rclone serve` protocols.
28871    ///
28872    ///Sends a `POST` request to `/serve/types`
28873    ///
28874    ///Arguments:
28875    /// - `async_`: Run the command asynchronously. Returns a job id
28876    ///   immediately.
28877    /// - `group`: Assign the request to a custom stats group.
28878    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28879    ///   instead of 200.
28880    /// - `body`
28881    pub async fn serve_types<'a>(
28882        &'a self,
28883        async_: Option<bool>,
28884        group: Option<&'a str>,
28885        prefer: Option<types::ServeTypesPrefer>,
28886        body: &'a types::ServeTypesRequest,
28887    ) -> Result<ResponseValue<types::ServeTypesResponse>, Error<types::RcError>> {
28888        let url = format!("{}/serve/types", self.baseurl,);
28889        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28890        header_map.append(
28891            ::reqwest::header::HeaderName::from_static("api-version"),
28892            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28893        );
28894        if let Some(value) = prefer {
28895            header_map.append("Prefer", value.to_string().try_into()?);
28896        }
28897
28898        #[allow(unused_mut)]
28899        let mut request = self
28900            .client
28901            .post(url)
28902            .header(
28903                ::reqwest::header::ACCEPT,
28904                ::reqwest::header::HeaderValue::from_static("application/json"),
28905            )
28906            .json(&body)
28907            .query(&progenitor_client::QueryParam::new("_async", &async_))
28908            .query(&progenitor_client::QueryParam::new("_group", &group))
28909            .headers(header_map)
28910            .build()?;
28911        let info = OperationInfo {
28912            operation_id: "serve_types",
28913        };
28914        self.pre(&mut request, &info).await?;
28915        let result = self.exec(request, &info).await;
28916        self.post(&result, &info).await?;
28917        let response = result?;
28918        match response.status().as_u16() {
28919            200u16 => ResponseValue::from_response(response).await,
28920            400u16..=499u16 => Err(Error::ErrorResponse(
28921                ResponseValue::from_response(response).await?,
28922            )),
28923            500u16..=599u16 => Err(Error::ErrorResponse(
28924                ResponseValue::from_response(response).await?,
28925            )),
28926            _ => Err(Error::UnexpectedResponse(response)),
28927        }
28928    }
28929
28930    ///Forget cached paths
28931    ///
28932    ///Evicts specific files or directories from the VFS directory cache.
28933    ///
28934    ///Sends a `POST` request to `/vfs/forget`
28935    ///
28936    ///Arguments:
28937    /// - `async_`: Run the command asynchronously. Returns a job id
28938    ///   immediately.
28939    /// - `group`: Assign the request to a custom stats group.
28940    /// - `fs`: Optional VFS identifier to target; required when more than one
28941    ///   VFS is active.
28942    /// - `params`: Additional arbitrary parameters allowed.
28943    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
28944    ///   instead of 200.
28945    /// - `body`
28946    pub async fn vfs_forget<'a>(
28947        &'a self,
28948        async_: Option<bool>,
28949        group: Option<&'a str>,
28950        fs: Option<&'a str>,
28951        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
28952        prefer: Option<types::VfsForgetPrefer>,
28953        body: &'a types::VfsForgetRequest,
28954    ) -> Result<ResponseValue<types::VfsForgetResponse>, Error<types::RcError>> {
28955        let url = format!("{}/vfs/forget", self.baseurl,);
28956        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
28957        header_map.append(
28958            ::reqwest::header::HeaderName::from_static("api-version"),
28959            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
28960        );
28961        if let Some(value) = prefer {
28962            header_map.append("Prefer", value.to_string().try_into()?);
28963        }
28964
28965        #[allow(unused_mut)]
28966        let mut request = self
28967            .client
28968            .post(url)
28969            .header(
28970                ::reqwest::header::ACCEPT,
28971                ::reqwest::header::HeaderValue::from_static("application/json"),
28972            )
28973            .json(&body)
28974            .query(&progenitor_client::QueryParam::new("_async", &async_))
28975            .query(&progenitor_client::QueryParam::new("_group", &group))
28976            .query(&progenitor_client::QueryParam::new("fs", &fs))
28977            .query(&progenitor_client::QueryParam::new("params", &params))
28978            .headers(header_map)
28979            .build()?;
28980        let info = OperationInfo {
28981            operation_id: "vfs_forget",
28982        };
28983        self.pre(&mut request, &info).await?;
28984        let result = self.exec(request, &info).await;
28985        self.post(&result, &info).await?;
28986        let response = result?;
28987        match response.status().as_u16() {
28988            200u16 => ResponseValue::from_response(response).await,
28989            400u16..=499u16 => Err(Error::ErrorResponse(
28990                ResponseValue::from_response(response).await?,
28991            )),
28992            500u16..=599u16 => Err(Error::ErrorResponse(
28993                ResponseValue::from_response(response).await?,
28994            )),
28995            _ => Err(Error::UnexpectedResponse(response)),
28996        }
28997    }
28998
28999    ///List VFS instances
29000    ///
29001    ///Lists the active VFS instances and their identifiers.
29002    ///
29003    ///Sends a `POST` request to `/vfs/list`
29004    ///
29005    ///Arguments:
29006    /// - `async_`: Run the command asynchronously. Returns a job id
29007    ///   immediately.
29008    /// - `group`: Assign the request to a custom stats group.
29009    /// - `fs`: Optional VFS identifier; omit to list all active VFS instances.
29010    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29011    ///   instead of 200.
29012    /// - `body`
29013    pub async fn vfs_list<'a>(
29014        &'a self,
29015        async_: Option<bool>,
29016        group: Option<&'a str>,
29017        fs: Option<&'a str>,
29018        prefer: Option<types::VfsListPrefer>,
29019        body: &'a types::VfsListRequest,
29020    ) -> Result<ResponseValue<types::VfsListResponse>, Error<types::RcError>> {
29021        let url = format!("{}/vfs/list", self.baseurl,);
29022        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29023        header_map.append(
29024            ::reqwest::header::HeaderName::from_static("api-version"),
29025            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29026        );
29027        if let Some(value) = prefer {
29028            header_map.append("Prefer", value.to_string().try_into()?);
29029        }
29030
29031        #[allow(unused_mut)]
29032        let mut request = self
29033            .client
29034            .post(url)
29035            .header(
29036                ::reqwest::header::ACCEPT,
29037                ::reqwest::header::HeaderValue::from_static("application/json"),
29038            )
29039            .json(&body)
29040            .query(&progenitor_client::QueryParam::new("_async", &async_))
29041            .query(&progenitor_client::QueryParam::new("_group", &group))
29042            .query(&progenitor_client::QueryParam::new("fs", &fs))
29043            .headers(header_map)
29044            .build()?;
29045        let info = OperationInfo {
29046            operation_id: "vfs_list",
29047        };
29048        self.pre(&mut request, &info).await?;
29049        let result = self.exec(request, &info).await;
29050        self.post(&result, &info).await?;
29051        let response = result?;
29052        match response.status().as_u16() {
29053            200u16 => ResponseValue::from_response(response).await,
29054            400u16..=499u16 => Err(Error::ErrorResponse(
29055                ResponseValue::from_response(response).await?,
29056            )),
29057            500u16..=599u16 => Err(Error::ErrorResponse(
29058                ResponseValue::from_response(response).await?,
29059            )),
29060            _ => Err(Error::UnexpectedResponse(response)),
29061        }
29062    }
29063
29064    ///Get or set poll interval
29065    ///
29066    ///Reads or updates the VFS poll interval duration, optionally waiting for
29067    /// the change to apply.
29068    ///
29069    ///Sends a `POST` request to `/vfs/poll-interval`
29070    ///
29071    ///Arguments:
29072    /// - `async_`: Run the command asynchronously. Returns a job id
29073    ///   immediately.
29074    /// - `group`: Assign the request to a custom stats group.
29075    /// - `fs`: Optional VFS identifier whose poll interval should be queried or
29076    ///   modified.
29077    /// - `interval`: Duration string (e.g. `5m`) to set as the new poll
29078    ///   interval.
29079    /// - `timeout`: Duration to wait for the poll interval change to take
29080    ///   effect; `0` waits indefinitely.
29081    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29082    ///   instead of 200.
29083    /// - `body`
29084    pub async fn vfs_poll_interval<'a>(
29085        &'a self,
29086        async_: Option<bool>,
29087        group: Option<&'a str>,
29088        fs: Option<&'a str>,
29089        interval: Option<&'a str>,
29090        timeout: Option<&'a str>,
29091        prefer: Option<types::VfsPollIntervalPrefer>,
29092        body: &'a types::VfsPollIntervalRequest,
29093    ) -> Result<
29094        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
29095        Error<types::RcError>,
29096    > {
29097        let url = format!("{}/vfs/poll-interval", self.baseurl,);
29098        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29099        header_map.append(
29100            ::reqwest::header::HeaderName::from_static("api-version"),
29101            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29102        );
29103        if let Some(value) = prefer {
29104            header_map.append("Prefer", value.to_string().try_into()?);
29105        }
29106
29107        #[allow(unused_mut)]
29108        let mut request = self
29109            .client
29110            .post(url)
29111            .header(
29112                ::reqwest::header::ACCEPT,
29113                ::reqwest::header::HeaderValue::from_static("application/json"),
29114            )
29115            .json(&body)
29116            .query(&progenitor_client::QueryParam::new("_async", &async_))
29117            .query(&progenitor_client::QueryParam::new("_group", &group))
29118            .query(&progenitor_client::QueryParam::new("fs", &fs))
29119            .query(&progenitor_client::QueryParam::new("interval", &interval))
29120            .query(&progenitor_client::QueryParam::new("timeout", &timeout))
29121            .headers(header_map)
29122            .build()?;
29123        let info = OperationInfo {
29124            operation_id: "vfs_poll_interval",
29125        };
29126        self.pre(&mut request, &info).await?;
29127        let result = self.exec(request, &info).await;
29128        self.post(&result, &info).await?;
29129        let response = result?;
29130        match response.status().as_u16() {
29131            200u16 => ResponseValue::from_response(response).await,
29132            400u16..=499u16 => Err(Error::ErrorResponse(
29133                ResponseValue::from_response(response).await?,
29134            )),
29135            500u16..=599u16 => Err(Error::ErrorResponse(
29136                ResponseValue::from_response(response).await?,
29137            )),
29138            _ => Err(Error::UnexpectedResponse(response)),
29139        }
29140    }
29141
29142    ///Inspect upload queue
29143    ///
29144    ///Returns the contents of the VFS upload queue.
29145    ///
29146    ///Sends a `POST` request to `/vfs/queue`
29147    ///
29148    ///Arguments:
29149    /// - `async_`: Run the command asynchronously. Returns a job id
29150    ///   immediately.
29151    /// - `group`: Assign the request to a custom stats group.
29152    /// - `fs`: Optional VFS identifier whose upload queue should be inspected.
29153    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29154    ///   instead of 200.
29155    /// - `body`
29156    pub async fn vfs_queue<'a>(
29157        &'a self,
29158        async_: Option<bool>,
29159        group: Option<&'a str>,
29160        fs: Option<&'a str>,
29161        prefer: Option<types::VfsQueuePrefer>,
29162        body: &'a types::VfsQueueRequest,
29163    ) -> Result<ResponseValue<types::VfsQueueResponse>, Error<types::RcError>> {
29164        let url = format!("{}/vfs/queue", self.baseurl,);
29165        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29166        header_map.append(
29167            ::reqwest::header::HeaderName::from_static("api-version"),
29168            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29169        );
29170        if let Some(value) = prefer {
29171            header_map.append("Prefer", value.to_string().try_into()?);
29172        }
29173
29174        #[allow(unused_mut)]
29175        let mut request = self
29176            .client
29177            .post(url)
29178            .header(
29179                ::reqwest::header::ACCEPT,
29180                ::reqwest::header::HeaderValue::from_static("application/json"),
29181            )
29182            .json(&body)
29183            .query(&progenitor_client::QueryParam::new("_async", &async_))
29184            .query(&progenitor_client::QueryParam::new("_group", &group))
29185            .query(&progenitor_client::QueryParam::new("fs", &fs))
29186            .headers(header_map)
29187            .build()?;
29188        let info = OperationInfo {
29189            operation_id: "vfs_queue",
29190        };
29191        self.pre(&mut request, &info).await?;
29192        let result = self.exec(request, &info).await;
29193        self.post(&result, &info).await?;
29194        let response = result?;
29195        match response.status().as_u16() {
29196            200u16 => ResponseValue::from_response(response).await,
29197            400u16..=499u16 => Err(Error::ErrorResponse(
29198                ResponseValue::from_response(response).await?,
29199            )),
29200            500u16..=599u16 => Err(Error::ErrorResponse(
29201                ResponseValue::from_response(response).await?,
29202            )),
29203            _ => Err(Error::UnexpectedResponse(response)),
29204        }
29205    }
29206
29207    ///Adjust queue expiry
29208    ///
29209    ///Sets the expiry time of a queued VFS upload item, optionally relative to
29210    /// its current value.
29211    ///
29212    ///Sends a `POST` request to `/vfs/queue-set-expiry`
29213    ///
29214    ///Arguments:
29215    /// - `async_`: Run the command asynchronously. Returns a job id
29216    ///   immediately.
29217    /// - `group`: Assign the request to a custom stats group.
29218    /// - `expiry`: New eligibility time in seconds (may be negative for
29219    ///   immediate upload).
29220    /// - `fs`: Optional VFS identifier for the queued item.
29221    /// - `id`: Queue item ID as returned by `vfs/queue`.
29222    /// - `relative`: Set to true to treat `expiry` as relative to the current
29223    ///   value.
29224    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29225    ///   instead of 200.
29226    /// - `body`
29227    pub async fn vfs_queue_set_expiry<'a>(
29228        &'a self,
29229        async_: Option<bool>,
29230        group: Option<&'a str>,
29231        expiry: Option<f64>,
29232        fs: Option<&'a str>,
29233        id: Option<i64>,
29234        relative: Option<bool>,
29235        prefer: Option<types::VfsQueueSetExpiryPrefer>,
29236        body: &'a types::VfsQueueSetExpiryRequest,
29237    ) -> Result<
29238        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
29239        Error<types::RcError>,
29240    > {
29241        let url = format!("{}/vfs/queue-set-expiry", self.baseurl,);
29242        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29243        header_map.append(
29244            ::reqwest::header::HeaderName::from_static("api-version"),
29245            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29246        );
29247        if let Some(value) = prefer {
29248            header_map.append("Prefer", value.to_string().try_into()?);
29249        }
29250
29251        #[allow(unused_mut)]
29252        let mut request = self
29253            .client
29254            .post(url)
29255            .header(
29256                ::reqwest::header::ACCEPT,
29257                ::reqwest::header::HeaderValue::from_static("application/json"),
29258            )
29259            .json(&body)
29260            .query(&progenitor_client::QueryParam::new("_async", &async_))
29261            .query(&progenitor_client::QueryParam::new("_group", &group))
29262            .query(&progenitor_client::QueryParam::new("expiry", &expiry))
29263            .query(&progenitor_client::QueryParam::new("fs", &fs))
29264            .query(&progenitor_client::QueryParam::new("id", &id))
29265            .query(&progenitor_client::QueryParam::new("relative", &relative))
29266            .headers(header_map)
29267            .build()?;
29268        let info = OperationInfo {
29269            operation_id: "vfs_queue_set_expiry",
29270        };
29271        self.pre(&mut request, &info).await?;
29272        let result = self.exec(request, &info).await;
29273        self.post(&result, &info).await?;
29274        let response = result?;
29275        match response.status().as_u16() {
29276            200u16 => ResponseValue::from_response(response).await,
29277            400u16..=499u16 => Err(Error::ErrorResponse(
29278                ResponseValue::from_response(response).await?,
29279            )),
29280            500u16..=599u16 => Err(Error::ErrorResponse(
29281                ResponseValue::from_response(response).await?,
29282            )),
29283            _ => Err(Error::UnexpectedResponse(response)),
29284        }
29285    }
29286
29287    ///Refresh directory cache
29288    ///
29289    ///Refreshes one or more directories in the VFS cache, optionally
29290    /// recursively.
29291    ///
29292    ///Sends a `POST` request to `/vfs/refresh`
29293    ///
29294    ///Arguments:
29295    /// - `async_`: Run the command asynchronously. Returns a job id
29296    ///   immediately.
29297    /// - `group`: Assign the request to a custom stats group.
29298    /// - `fs`: Optional VFS identifier whose directory cache should be
29299    ///   refreshed.
29300    /// - `params`: Additional arbitrary parameters allowed.
29301    /// - `recursive`: Set to true to refresh entire directory trees.
29302    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29303    ///   instead of 200.
29304    /// - `body`
29305    pub async fn vfs_refresh<'a>(
29306        &'a self,
29307        async_: Option<bool>,
29308        group: Option<&'a str>,
29309        fs: Option<&'a str>,
29310        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
29311        recursive: Option<bool>,
29312        prefer: Option<types::VfsRefreshPrefer>,
29313        body: &'a types::VfsRefreshRequest,
29314    ) -> Result<ResponseValue<types::VfsRefreshResponse>, Error<types::RcError>> {
29315        let url = format!("{}/vfs/refresh", self.baseurl,);
29316        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29317        header_map.append(
29318            ::reqwest::header::HeaderName::from_static("api-version"),
29319            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29320        );
29321        if let Some(value) = prefer {
29322            header_map.append("Prefer", value.to_string().try_into()?);
29323        }
29324
29325        #[allow(unused_mut)]
29326        let mut request = self
29327            .client
29328            .post(url)
29329            .header(
29330                ::reqwest::header::ACCEPT,
29331                ::reqwest::header::HeaderValue::from_static("application/json"),
29332            )
29333            .json(&body)
29334            .query(&progenitor_client::QueryParam::new("_async", &async_))
29335            .query(&progenitor_client::QueryParam::new("_group", &group))
29336            .query(&progenitor_client::QueryParam::new("fs", &fs))
29337            .query(&progenitor_client::QueryParam::new("params", &params))
29338            .query(&progenitor_client::QueryParam::new("recursive", &recursive))
29339            .headers(header_map)
29340            .build()?;
29341        let info = OperationInfo {
29342            operation_id: "vfs_refresh",
29343        };
29344        self.pre(&mut request, &info).await?;
29345        let result = self.exec(request, &info).await;
29346        self.post(&result, &info).await?;
29347        let response = result?;
29348        match response.status().as_u16() {
29349            200u16 => ResponseValue::from_response(response).await,
29350            400u16..=499u16 => Err(Error::ErrorResponse(
29351                ResponseValue::from_response(response).await?,
29352            )),
29353            500u16..=599u16 => Err(Error::ErrorResponse(
29354                ResponseValue::from_response(response).await?,
29355            )),
29356            _ => Err(Error::UnexpectedResponse(response)),
29357        }
29358    }
29359
29360    ///Show VFS stats
29361    ///
29362    ///Returns VFS statistics including disk cache usage and metadata cache
29363    /// counters.
29364    ///
29365    ///Sends a `POST` request to `/vfs/stats`
29366    ///
29367    ///Arguments:
29368    /// - `async_`: Run the command asynchronously. Returns a job id
29369    ///   immediately.
29370    /// - `group`: Assign the request to a custom stats group.
29371    /// - `fs`: Optional VFS identifier whose statistics should be returned.
29372    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29373    ///   instead of 200.
29374    /// - `body`
29375    pub async fn vfs_stats<'a>(
29376        &'a self,
29377        async_: Option<bool>,
29378        group: Option<&'a str>,
29379        fs: Option<&'a str>,
29380        prefer: Option<types::VfsStatsPrefer>,
29381        body: &'a types::VfsStatsRequest,
29382    ) -> Result<ResponseValue<types::VfsStatsResponse>, Error<types::RcError>> {
29383        let url = format!("{}/vfs/stats", self.baseurl,);
29384        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29385        header_map.append(
29386            ::reqwest::header::HeaderName::from_static("api-version"),
29387            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29388        );
29389        if let Some(value) = prefer {
29390            header_map.append("Prefer", value.to_string().try_into()?);
29391        }
29392
29393        #[allow(unused_mut)]
29394        let mut request = self
29395            .client
29396            .post(url)
29397            .header(
29398                ::reqwest::header::ACCEPT,
29399                ::reqwest::header::HeaderValue::from_static("application/json"),
29400            )
29401            .json(&body)
29402            .query(&progenitor_client::QueryParam::new("_async", &async_))
29403            .query(&progenitor_client::QueryParam::new("_group", &group))
29404            .query(&progenitor_client::QueryParam::new("fs", &fs))
29405            .headers(header_map)
29406            .build()?;
29407        let info = OperationInfo {
29408            operation_id: "vfs_stats",
29409        };
29410        self.pre(&mut request, &info).await?;
29411        let result = self.exec(request, &info).await;
29412        self.post(&result, &info).await?;
29413        let response = result?;
29414        match response.status().as_u16() {
29415            200u16 => ResponseValue::from_response(response).await,
29416            400u16..=499u16 => Err(Error::ErrorResponse(
29417                ResponseValue::from_response(response).await?,
29418            )),
29419            500u16..=599u16 => Err(Error::ErrorResponse(
29420                ResponseValue::from_response(response).await?,
29421            )),
29422            _ => Err(Error::UnexpectedResponse(response)),
29423        }
29424    }
29425
29426    ///Install plugin
29427    ///
29428    ///Downloads and installs a plugin into the WebUI from the provided
29429    /// repository URL.
29430    ///
29431    ///Sends a `POST` request to `/pluginsctl/addPlugin`
29432    ///
29433    ///Arguments:
29434    /// - `async_`: Run the command asynchronously. Returns a job id
29435    ///   immediately.
29436    /// - `group`: Assign the request to a custom stats group.
29437    /// - `url`: Repository URL of the plugin to install.
29438    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29439    ///   instead of 200.
29440    /// - `body`
29441    pub async fn pluginsctl_add_plugin<'a>(
29442        &'a self,
29443        async_: Option<bool>,
29444        group: Option<&'a str>,
29445        url: Option<&'a str>,
29446        prefer: Option<types::PluginsctlAddPluginPrefer>,
29447        body: &'a types::PluginsctlAddPluginRequest,
29448    ) -> Result<
29449        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
29450        Error<types::RcError>,
29451    > {
29452        let _url = format!("{}/pluginsctl/addPlugin", self.baseurl,);
29453        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29454        header_map.append(
29455            ::reqwest::header::HeaderName::from_static("api-version"),
29456            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29457        );
29458        if let Some(value) = prefer {
29459            header_map.append("Prefer", value.to_string().try_into()?);
29460        }
29461
29462        #[allow(unused_mut)]
29463        let mut request = self
29464            .client
29465            .post(_url)
29466            .header(
29467                ::reqwest::header::ACCEPT,
29468                ::reqwest::header::HeaderValue::from_static("application/json"),
29469            )
29470            .json(&body)
29471            .query(&progenitor_client::QueryParam::new("_async", &async_))
29472            .query(&progenitor_client::QueryParam::new("_group", &group))
29473            .query(&progenitor_client::QueryParam::new("url", &url))
29474            .headers(header_map)
29475            .build()?;
29476        let info = OperationInfo {
29477            operation_id: "pluginsctl_add_plugin",
29478        };
29479        self.pre(&mut request, &info).await?;
29480        let result = self.exec(request, &info).await;
29481        self.post(&result, &info).await?;
29482        let response = result?;
29483        match response.status().as_u16() {
29484            200u16 => ResponseValue::from_response(response).await,
29485            400u16..=499u16 => Err(Error::ErrorResponse(
29486                ResponseValue::from_response(response).await?,
29487            )),
29488            500u16..=599u16 => Err(Error::ErrorResponse(
29489                ResponseValue::from_response(response).await?,
29490            )),
29491            _ => Err(Error::UnexpectedResponse(response)),
29492        }
29493    }
29494
29495    ///Filter plugins by MIME type
29496    ///
29497    ///Returns plugins matching the requested MIME type and optional plugin
29498    /// type.
29499    ///
29500    ///Sends a `POST` request to `/pluginsctl/getPluginsForType`
29501    ///
29502    ///Arguments:
29503    /// - `async_`: Run the command asynchronously. Returns a job id
29504    ///   immediately.
29505    /// - `group`: Assign the request to a custom stats group.
29506    /// - `plugin_type`: Filter results by plugin type (e.g. `test`).
29507    /// - `type_`: MIME type to match when listing plugins.
29508    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29509    ///   instead of 200.
29510    /// - `body`
29511    pub async fn pluginsctl_get_plugins_for_type<'a>(
29512        &'a self,
29513        async_: Option<bool>,
29514        group: Option<&'a str>,
29515        plugin_type: Option<&'a str>,
29516        type_: Option<&'a str>,
29517        prefer: Option<types::PluginsctlGetPluginsForTypePrefer>,
29518        body: &'a types::PluginsctlGetPluginsForTypeRequest,
29519    ) -> Result<ResponseValue<types::PluginsctlGetPluginsForTypeResponse>, Error<types::RcError>>
29520    {
29521        let url = format!("{}/pluginsctl/getPluginsForType", self.baseurl,);
29522        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29523        header_map.append(
29524            ::reqwest::header::HeaderName::from_static("api-version"),
29525            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29526        );
29527        if let Some(value) = prefer {
29528            header_map.append("Prefer", value.to_string().try_into()?);
29529        }
29530
29531        #[allow(unused_mut)]
29532        let mut request = self
29533            .client
29534            .post(url)
29535            .header(
29536                ::reqwest::header::ACCEPT,
29537                ::reqwest::header::HeaderValue::from_static("application/json"),
29538            )
29539            .json(&body)
29540            .query(&progenitor_client::QueryParam::new("_async", &async_))
29541            .query(&progenitor_client::QueryParam::new("_group", &group))
29542            .query(&progenitor_client::QueryParam::new(
29543                "pluginType",
29544                &plugin_type,
29545            ))
29546            .query(&progenitor_client::QueryParam::new("type", &type_))
29547            .headers(header_map)
29548            .build()?;
29549        let info = OperationInfo {
29550            operation_id: "pluginsctl_get_plugins_for_type",
29551        };
29552        self.pre(&mut request, &info).await?;
29553        let result = self.exec(request, &info).await;
29554        self.post(&result, &info).await?;
29555        let response = result?;
29556        match response.status().as_u16() {
29557            200u16 => ResponseValue::from_response(response).await,
29558            400u16..=499u16 => Err(Error::ErrorResponse(
29559                ResponseValue::from_response(response).await?,
29560            )),
29561            500u16..=599u16 => Err(Error::ErrorResponse(
29562                ResponseValue::from_response(response).await?,
29563            )),
29564            _ => Err(Error::UnexpectedResponse(response)),
29565        }
29566    }
29567
29568    ///List installed plugins
29569    ///
29570    ///Returns metadata for installed production and test plugins.
29571    ///
29572    ///Sends a `POST` request to `/pluginsctl/listPlugins`
29573    ///
29574    ///Arguments:
29575    /// - `async_`: Run the command asynchronously. Returns a job id
29576    ///   immediately.
29577    /// - `group`: Assign the request to a custom stats group.
29578    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29579    ///   instead of 200.
29580    /// - `body`
29581    pub async fn pluginsctl_list_plugins<'a>(
29582        &'a self,
29583        async_: Option<bool>,
29584        group: Option<&'a str>,
29585        prefer: Option<types::PluginsctlListPluginsPrefer>,
29586        body: &'a types::PluginsctlListPluginsRequest,
29587    ) -> Result<ResponseValue<types::PluginsctlListPluginsResponse>, Error<types::RcError>> {
29588        let url = format!("{}/pluginsctl/listPlugins", self.baseurl,);
29589        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29590        header_map.append(
29591            ::reqwest::header::HeaderName::from_static("api-version"),
29592            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29593        );
29594        if let Some(value) = prefer {
29595            header_map.append("Prefer", value.to_string().try_into()?);
29596        }
29597
29598        #[allow(unused_mut)]
29599        let mut request = self
29600            .client
29601            .post(url)
29602            .header(
29603                ::reqwest::header::ACCEPT,
29604                ::reqwest::header::HeaderValue::from_static("application/json"),
29605            )
29606            .json(&body)
29607            .query(&progenitor_client::QueryParam::new("_async", &async_))
29608            .query(&progenitor_client::QueryParam::new("_group", &group))
29609            .headers(header_map)
29610            .build()?;
29611        let info = OperationInfo {
29612            operation_id: "pluginsctl_list_plugins",
29613        };
29614        self.pre(&mut request, &info).await?;
29615        let result = self.exec(request, &info).await;
29616        self.post(&result, &info).await?;
29617        let response = result?;
29618        match response.status().as_u16() {
29619            200u16 => ResponseValue::from_response(response).await,
29620            400u16..=499u16 => Err(Error::ErrorResponse(
29621                ResponseValue::from_response(response).await?,
29622            )),
29623            500u16..=599u16 => Err(Error::ErrorResponse(
29624                ResponseValue::from_response(response).await?,
29625            )),
29626            _ => Err(Error::UnexpectedResponse(response)),
29627        }
29628    }
29629
29630    ///List installed test plugins
29631    ///
29632    ///Returns metadata for installed test plugins.
29633    ///
29634    ///Sends a `POST` request to `/pluginsctl/listTestPlugins`
29635    ///
29636    ///Arguments:
29637    /// - `async_`: Run the command asynchronously. Returns a job id
29638    ///   immediately.
29639    /// - `group`: Assign the request to a custom stats group.
29640    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29641    ///   instead of 200.
29642    /// - `body`
29643    pub async fn pluginsctl_list_test_plugins<'a>(
29644        &'a self,
29645        async_: Option<bool>,
29646        group: Option<&'a str>,
29647        prefer: Option<types::PluginsctlListTestPluginsPrefer>,
29648        body: &'a types::PluginsctlListTestPluginsRequest,
29649    ) -> Result<ResponseValue<types::PluginsctlListTestPluginsResponse>, Error<types::RcError>>
29650    {
29651        let url = format!("{}/pluginsctl/listTestPlugins", self.baseurl,);
29652        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29653        header_map.append(
29654            ::reqwest::header::HeaderName::from_static("api-version"),
29655            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29656        );
29657        if let Some(value) = prefer {
29658            header_map.append("Prefer", value.to_string().try_into()?);
29659        }
29660
29661        #[allow(unused_mut)]
29662        let mut request = self
29663            .client
29664            .post(url)
29665            .header(
29666                ::reqwest::header::ACCEPT,
29667                ::reqwest::header::HeaderValue::from_static("application/json"),
29668            )
29669            .json(&body)
29670            .query(&progenitor_client::QueryParam::new("_async", &async_))
29671            .query(&progenitor_client::QueryParam::new("_group", &group))
29672            .headers(header_map)
29673            .build()?;
29674        let info = OperationInfo {
29675            operation_id: "pluginsctl_list_test_plugins",
29676        };
29677        self.pre(&mut request, &info).await?;
29678        let result = self.exec(request, &info).await;
29679        self.post(&result, &info).await?;
29680        let response = result?;
29681        match response.status().as_u16() {
29682            200u16 => ResponseValue::from_response(response).await,
29683            400u16..=499u16 => Err(Error::ErrorResponse(
29684                ResponseValue::from_response(response).await?,
29685            )),
29686            500u16..=599u16 => Err(Error::ErrorResponse(
29687                ResponseValue::from_response(response).await?,
29688            )),
29689            _ => Err(Error::UnexpectedResponse(response)),
29690        }
29691    }
29692
29693    ///Remove plugin
29694    ///
29695    ///Uninstalls a plugin from the WebUI.
29696    ///
29697    ///Sends a `POST` request to `/pluginsctl/removePlugin`
29698    ///
29699    ///Arguments:
29700    /// - `async_`: Run the command asynchronously. Returns a job id
29701    ///   immediately.
29702    /// - `group`: Assign the request to a custom stats group.
29703    /// - `name`: Name of the plugin to uninstall.
29704    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29705    ///   instead of 200.
29706    /// - `body`
29707    pub async fn pluginsctl_remove_plugin<'a>(
29708        &'a self,
29709        async_: Option<bool>,
29710        group: Option<&'a str>,
29711        name: Option<&'a str>,
29712        prefer: Option<types::PluginsctlRemovePluginPrefer>,
29713        body: &'a types::PluginsctlRemovePluginRequest,
29714    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
29715        let url = format!("{}/pluginsctl/removePlugin", self.baseurl,);
29716        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29717        header_map.append(
29718            ::reqwest::header::HeaderName::from_static("api-version"),
29719            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29720        );
29721        if let Some(value) = prefer {
29722            header_map.append("Prefer", value.to_string().try_into()?);
29723        }
29724
29725        #[allow(unused_mut)]
29726        let mut request = self
29727            .client
29728            .post(url)
29729            .header(
29730                ::reqwest::header::ACCEPT,
29731                ::reqwest::header::HeaderValue::from_static("application/json"),
29732            )
29733            .json(&body)
29734            .query(&progenitor_client::QueryParam::new("_async", &async_))
29735            .query(&progenitor_client::QueryParam::new("_group", &group))
29736            .query(&progenitor_client::QueryParam::new("name", &name))
29737            .headers(header_map)
29738            .build()?;
29739        let info = OperationInfo {
29740            operation_id: "pluginsctl_remove_plugin",
29741        };
29742        self.pre(&mut request, &info).await?;
29743        let result = self.exec(request, &info).await;
29744        self.post(&result, &info).await?;
29745        let response = result?;
29746        match response.status().as_u16() {
29747            200u16 => Ok(ResponseValue::empty(response)),
29748            400u16..=499u16 => Err(Error::ErrorResponse(
29749                ResponseValue::from_response(response).await?,
29750            )),
29751            500u16..=599u16 => Err(Error::ErrorResponse(
29752                ResponseValue::from_response(response).await?,
29753            )),
29754            _ => Err(Error::UnexpectedResponse(response)),
29755        }
29756    }
29757
29758    ///Remove test plugin
29759    ///
29760    ///Uninstalls a test plugin from the WebUI.
29761    ///
29762    ///Sends a `POST` request to `/pluginsctl/removeTestPlugin`
29763    ///
29764    ///Arguments:
29765    /// - `async_`: Run the command asynchronously. Returns a job id
29766    ///   immediately.
29767    /// - `group`: Assign the request to a custom stats group.
29768    /// - `name`: Name of the test plugin to uninstall.
29769    /// - `prefer`: Set to "respond-async" with _async=true to receive HTTP 202
29770    ///   instead of 200.
29771    /// - `body`
29772    pub async fn pluginsctl_remove_test_plugin<'a>(
29773        &'a self,
29774        async_: Option<bool>,
29775        group: Option<&'a str>,
29776        name: Option<&'a str>,
29777        prefer: Option<types::PluginsctlRemoveTestPluginPrefer>,
29778        body: &'a types::PluginsctlRemoveTestPluginRequest,
29779    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
29780        let url = format!("{}/pluginsctl/removeTestPlugin", self.baseurl,);
29781        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(2usize);
29782        header_map.append(
29783            ::reqwest::header::HeaderName::from_static("api-version"),
29784            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
29785        );
29786        if let Some(value) = prefer {
29787            header_map.append("Prefer", value.to_string().try_into()?);
29788        }
29789
29790        #[allow(unused_mut)]
29791        let mut request = self
29792            .client
29793            .post(url)
29794            .header(
29795                ::reqwest::header::ACCEPT,
29796                ::reqwest::header::HeaderValue::from_static("application/json"),
29797            )
29798            .json(&body)
29799            .query(&progenitor_client::QueryParam::new("_async", &async_))
29800            .query(&progenitor_client::QueryParam::new("_group", &group))
29801            .query(&progenitor_client::QueryParam::new("name", &name))
29802            .headers(header_map)
29803            .build()?;
29804        let info = OperationInfo {
29805            operation_id: "pluginsctl_remove_test_plugin",
29806        };
29807        self.pre(&mut request, &info).await?;
29808        let result = self.exec(request, &info).await;
29809        self.post(&result, &info).await?;
29810        let response = result?;
29811        match response.status().as_u16() {
29812            200u16 => Ok(ResponseValue::empty(response)),
29813            400u16..=499u16 => Err(Error::ErrorResponse(
29814                ResponseValue::from_response(response).await?,
29815            )),
29816            500u16..=599u16 => Err(Error::ErrorResponse(
29817                ResponseValue::from_response(response).await?,
29818            )),
29819            _ => Err(Error::UnexpectedResponse(response)),
29820        }
29821    }
29822}
29823
29824/// Items consumers will typically use such as the Client.
29825pub mod prelude {
29826    #[allow(unused_imports)]
29827    pub use super::Client;
29828}
29829
29830
29831// ---- rclone-sdk hand-written overrides (see src/overrides.rs) ----
29832pub mod overrides;
29833pub use overrides::*;
rclone_sdk/lib.rs

rclone_sdk/
lib.rs
