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    ///`BackendCommandResponse`
39    ///
40    /// <details><summary>JSON schema</summary>
41    ///
42    /// ```json
43    ///{
44    ///  "type": "object",
45    ///  "properties": {
46    ///    "result": {
47    ///      "description": "Backend command result payload"
48    ///    }
49    ///  },
50    ///  "additionalProperties": true
51    ///}
52    /// ```
53    /// </details>
54    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
55    pub struct BackendCommandResponse {
56        ///Backend command result payload
57        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
58        pub result: ::std::option::Option<::serde_json::Value>,
59    }
60
61    impl ::std::convert::From<&BackendCommandResponse> for BackendCommandResponse {
62        fn from(value: &BackendCommandResponse) -> Self {
63            value.clone()
64        }
65    }
66
67    impl ::std::default::Default for BackendCommandResponse {
68        fn default() -> Self {
69            Self {
70                result: Default::default(),
71            }
72        }
73    }
74
75    ///`ConfigGetResponse`
76    ///
77    /// <details><summary>JSON schema</summary>
78    ///
79    /// ```json
80    ///{
81    ///  "type": "object",
82    ///  "required": [
83    ///    "type"
84    ///  ],
85    ///  "properties": {
86    ///    "provider": {
87    ///      "type": "string"
88    ///    },
89    ///    "type": {
90    ///      "type": "string"
91    ///    }
92    ///  },
93    ///  "additionalProperties": true
94    ///}
95    /// ```
96    /// </details>
97    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
98    pub struct ConfigGetResponse {
99        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
100        pub provider: ::std::option::Option<::std::string::String>,
101        #[serde(rename = "type")]
102        pub type_: ::std::string::String,
103    }
104
105    impl ::std::convert::From<&ConfigGetResponse> for ConfigGetResponse {
106        fn from(value: &ConfigGetResponse) -> Self {
107            value.clone()
108        }
109    }
110
111    ///`ConfigListremotesResponse`
112    ///
113    /// <details><summary>JSON schema</summary>
114    ///
115    /// ```json
116    ///{
117    ///  "type": "object",
118    ///  "required": [
119    ///    "remotes"
120    ///  ],
121    ///  "properties": {
122    ///    "remotes": {
123    ///      "type": "array",
124    ///      "items": {
125    ///        "type": "string"
126    ///      }
127    ///    }
128    ///  }
129    ///}
130    /// ```
131    /// </details>
132    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
133    pub struct ConfigListremotesResponse {
134        pub remotes: ::std::vec::Vec<::std::string::String>,
135    }
136
137    impl ::std::convert::From<&ConfigListremotesResponse> for ConfigListremotesResponse {
138        fn from(value: &ConfigListremotesResponse) -> Self {
139            value.clone()
140        }
141    }
142
143    ///`ConfigPathsResponse`
144    ///
145    /// <details><summary>JSON schema</summary>
146    ///
147    /// ```json
148    ///{
149    ///  "type": "object",
150    ///  "required": [
151    ///    "cache",
152    ///    "config",
153    ///    "temp"
154    ///  ],
155    ///  "properties": {
156    ///    "cache": {
157    ///      "type": "string"
158    ///    },
159    ///    "config": {
160    ///      "type": "string"
161    ///    },
162    ///    "temp": {
163    ///      "type": "string"
164    ///    }
165    ///  }
166    ///}
167    /// ```
168    /// </details>
169    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
170    pub struct ConfigPathsResponse {
171        pub cache: ::std::string::String,
172        pub config: ::std::string::String,
173        pub temp: ::std::string::String,
174    }
175
176    impl ::std::convert::From<&ConfigPathsResponse> for ConfigPathsResponse {
177        fn from(value: &ConfigPathsResponse) -> Self {
178            value.clone()
179        }
180    }
181
182    ///`ConfigProvider`
183    ///
184    /// <details><summary>JSON schema</summary>
185    ///
186    /// ```json
187    ///{
188    ///  "type": "object",
189    ///  "required": [
190    ///    "Description",
191    ///    "Name",
192    ///    "Options",
193    ///    "Prefix"
194    ///  ],
195    ///  "properties": {
196    ///    "Aliases": {
197    ///      "type": [
198    ///        "array",
199    ///        "null"
200    ///      ],
201    ///      "items": {
202    ///        "type": "string"
203    ///      }
204    ///    },
205    ///    "CommandHelp": {
206    ///      "type": [
207    ///        "array",
208    ///        "null"
209    ///      ],
210    ///      "items": {
211    ///        "$ref": "#/components/schemas/ConfigProviderCommandHelp"
212    ///      }
213    ///    },
214    ///    "Description": {
215    ///      "type": "string"
216    ///    },
217    ///    "Hide": {
218    ///      "type": "boolean"
219    ///    },
220    ///    "MetadataInfo": {
221    ///      "$ref": "#/components/schemas/ConfigProviderMetadataInfo"
222    ///    },
223    ///    "Name": {
224    ///      "type": "string"
225    ///    },
226    ///    "Options": {
227    ///      "type": "array",
228    ///      "items": {
229    ///        "$ref": "#/components/schemas/ConfigProviderOption"
230    ///      }
231    ///    },
232    ///    "Prefix": {
233    ///      "type": "string"
234    ///    }
235    ///  },
236    ///  "additionalProperties": true
237    ///}
238    /// ```
239    /// </details>
240    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
241    pub struct ConfigProvider {
242        #[serde(
243            rename = "Aliases",
244            default,
245            skip_serializing_if = "::std::option::Option::is_none"
246        )]
247        pub aliases: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
248        #[serde(
249            rename = "CommandHelp",
250            default,
251            skip_serializing_if = "::std::option::Option::is_none"
252        )]
253        pub command_help: ::std::option::Option<::std::vec::Vec<ConfigProviderCommandHelp>>,
254        #[serde(rename = "Description")]
255        pub description: ::std::string::String,
256        #[serde(
257            rename = "Hide",
258            default,
259            skip_serializing_if = "::std::option::Option::is_none"
260        )]
261        pub hide: ::std::option::Option<bool>,
262        #[serde(
263            rename = "MetadataInfo",
264            default,
265            skip_serializing_if = "::std::option::Option::is_none"
266        )]
267        pub metadata_info: ::std::option::Option<ConfigProviderMetadataInfo>,
268        #[serde(rename = "Name")]
269        pub name: ::std::string::String,
270        #[serde(rename = "Options")]
271        pub options: ::std::vec::Vec<ConfigProviderOption>,
272        #[serde(rename = "Prefix")]
273        pub prefix: ::std::string::String,
274    }
275
276    impl ::std::convert::From<&ConfigProvider> for ConfigProvider {
277        fn from(value: &ConfigProvider) -> Self {
278            value.clone()
279        }
280    }
281
282    ///`ConfigProviderCommandHelp`
283    ///
284    /// <details><summary>JSON schema</summary>
285    ///
286    /// ```json
287    ///{
288    ///  "type": "object",
289    ///  "properties": {
290    ///    "Long": {
291    ///      "type": "string"
292    ///    },
293    ///    "Name": {
294    ///      "type": "string"
295    ///    },
296    ///    "Opts": {
297    ///      "type": [
298    ///        "object",
299    ///        "null"
300    ///      ],
301    ///      "additionalProperties": true
302    ///    },
303    ///    "Short": {
304    ///      "type": "string"
305    ///    }
306    ///  },
307    ///  "additionalProperties": true
308    ///}
309    /// ```
310    /// </details>
311    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
312    pub struct ConfigProviderCommandHelp {
313        #[serde(
314            rename = "Long",
315            default,
316            skip_serializing_if = "::std::option::Option::is_none"
317        )]
318        pub long: ::std::option::Option<::std::string::String>,
319        #[serde(
320            rename = "Name",
321            default,
322            skip_serializing_if = "::std::option::Option::is_none"
323        )]
324        pub name: ::std::option::Option<::std::string::String>,
325        #[serde(
326            rename = "Opts",
327            default,
328            skip_serializing_if = "::std::option::Option::is_none"
329        )]
330        pub opts:
331            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
332        #[serde(
333            rename = "Short",
334            default,
335            skip_serializing_if = "::std::option::Option::is_none"
336        )]
337        pub short: ::std::option::Option<::std::string::String>,
338    }
339
340    impl ::std::convert::From<&ConfigProviderCommandHelp> for ConfigProviderCommandHelp {
341        fn from(value: &ConfigProviderCommandHelp) -> Self {
342            value.clone()
343        }
344    }
345
346    impl ::std::default::Default for ConfigProviderCommandHelp {
347        fn default() -> Self {
348            Self {
349                long: Default::default(),
350                name: Default::default(),
351                opts: Default::default(),
352                short: Default::default(),
353            }
354        }
355    }
356
357    ///`ConfigProviderMetadataInfo`
358    ///
359    /// <details><summary>JSON schema</summary>
360    ///
361    /// ```json
362    ///{
363    ///  "type": "object",
364    ///  "properties": {
365    ///    "Help": {
366    ///      "type": "string"
367    ///    },
368    ///    "System": {
369    ///      "type": [
370    ///        "object",
371    ///        "null"
372    ///      ],
373    ///      "additionalProperties": {
374    ///        "$ref": "#/components/schemas/ConfigProviderMetadataSystemEntry"
375    ///      }
376    ///    }
377    ///  },
378    ///  "additionalProperties": true
379    ///}
380    /// ```
381    /// </details>
382    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
383    pub struct ConfigProviderMetadataInfo {
384        #[serde(
385            rename = "Help",
386            default,
387            skip_serializing_if = "::std::option::Option::is_none"
388        )]
389        pub help: ::std::option::Option<::std::string::String>,
390        #[serde(
391            rename = "System",
392            default,
393            skip_serializing_if = "::std::option::Option::is_none"
394        )]
395        pub system: ::std::option::Option<
396            ::std::collections::HashMap<::std::string::String, ConfigProviderMetadataSystemEntry>,
397        >,
398    }
399
400    impl ::std::convert::From<&ConfigProviderMetadataInfo> for ConfigProviderMetadataInfo {
401        fn from(value: &ConfigProviderMetadataInfo) -> Self {
402            value.clone()
403        }
404    }
405
406    impl ::std::default::Default for ConfigProviderMetadataInfo {
407        fn default() -> Self {
408            Self {
409                help: Default::default(),
410                system: Default::default(),
411            }
412        }
413    }
414
415    ///`ConfigProviderMetadataSystemEntry`
416    ///
417    /// <details><summary>JSON schema</summary>
418    ///
419    /// ```json
420    ///{
421    ///  "type": "object",
422    ///  "properties": {
423    ///    "Example": {
424    ///      "type": "string"
425    ///    },
426    ///    "Help": {
427    ///      "type": "string"
428    ///    },
429    ///    "ReadOnly": {
430    ///      "type": "boolean"
431    ///    },
432    ///    "Type": {
433    ///      "type": "string"
434    ///    }
435    ///  },
436    ///  "additionalProperties": true
437    ///}
438    /// ```
439    /// </details>
440    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
441    pub struct ConfigProviderMetadataSystemEntry {
442        #[serde(
443            rename = "Example",
444            default,
445            skip_serializing_if = "::std::option::Option::is_none"
446        )]
447        pub example: ::std::option::Option<::std::string::String>,
448        #[serde(
449            rename = "Help",
450            default,
451            skip_serializing_if = "::std::option::Option::is_none"
452        )]
453        pub help: ::std::option::Option<::std::string::String>,
454        #[serde(
455            rename = "ReadOnly",
456            default,
457            skip_serializing_if = "::std::option::Option::is_none"
458        )]
459        pub read_only: ::std::option::Option<bool>,
460        #[serde(
461            rename = "Type",
462            default,
463            skip_serializing_if = "::std::option::Option::is_none"
464        )]
465        pub type_: ::std::option::Option<::std::string::String>,
466    }
467
468    impl ::std::convert::From<&ConfigProviderMetadataSystemEntry>
469        for ConfigProviderMetadataSystemEntry
470    {
471        fn from(value: &ConfigProviderMetadataSystemEntry) -> Self {
472            value.clone()
473        }
474    }
475
476    impl ::std::default::Default for ConfigProviderMetadataSystemEntry {
477        fn default() -> Self {
478            Self {
479                example: Default::default(),
480                help: Default::default(),
481                read_only: Default::default(),
482                type_: Default::default(),
483            }
484        }
485    }
486
487    ///`ConfigProviderOption`
488    ///
489    /// <details><summary>JSON schema</summary>
490    ///
491    /// ```json
492    ///{
493    ///  "type": "object",
494    ///  "required": [
495    ///    "Advanced",
496    ///    "Default",
497    ///    "DefaultStr",
498    ///    "Exclusive",
499    ///    "FieldName",
500    ///    "Help",
501    ///    "Hide",
502    ///    "IsPassword",
503    ///    "Name",
504    ///    "NoPrefix",
505    ///    "Required",
506    ///    "Sensitive",
507    ///    "Type",
508    ///    "Value",
509    ///    "ValueStr"
510    ///  ],
511    ///  "properties": {
512    ///    "Advanced": {
513    ///      "type": "boolean"
514    ///    },
515    ///    "Default": {
516    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
517    ///    },
518    ///    "DefaultStr": {
519    ///      "type": "string"
520    ///    },
521    ///    "Examples": {
522    ///      "type": "array",
523    ///      "items": {
524    ///        "$ref": "#/components/schemas/ConfigProviderOptionExample"
525    ///      }
526    ///    },
527    ///    "Exclusive": {
528    ///      "type": "boolean"
529    ///    },
530    ///    "FieldName": {
531    ///      "type": "string"
532    ///    },
533    ///    "Help": {
534    ///      "type": "string"
535    ///    },
536    ///    "Hide": {
537    ///      "type": "number"
538    ///    },
539    ///    "IsPassword": {
540    ///      "type": "boolean"
541    ///    },
542    ///    "Name": {
543    ///      "type": "string"
544    ///    },
545    ///    "NoPrefix": {
546    ///      "type": "boolean"
547    ///    },
548    ///    "Provider": {
549    ///      "type": "string"
550    ///    },
551    ///    "Required": {
552    ///      "type": "boolean"
553    ///    },
554    ///    "Sensitive": {
555    ///      "type": "boolean"
556    ///    },
557    ///    "ShortOpt": {
558    ///      "type": "string"
559    ///    },
560    ///    "Type": {
561    ///      "$ref": "#/components/schemas/ConfigProviderOptionType"
562    ///    },
563    ///    "Value": {
564    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
565    ///    },
566    ///    "ValueStr": {
567    ///      "type": "string"
568    ///    }
569    ///  },
570    ///  "additionalProperties": true
571    ///}
572    /// ```
573    /// </details>
574    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
575    pub struct ConfigProviderOption {
576        #[serde(rename = "Advanced")]
577        pub advanced: bool,
578        #[serde(rename = "Default")]
579        pub default: ConfigProviderOptionAny,
580        #[serde(rename = "DefaultStr")]
581        pub default_str: ::std::string::String,
582        #[serde(
583            rename = "Examples",
584            default,
585            skip_serializing_if = "::std::vec::Vec::is_empty"
586        )]
587        pub examples: ::std::vec::Vec<ConfigProviderOptionExample>,
588        #[serde(rename = "Exclusive")]
589        pub exclusive: bool,
590        #[serde(rename = "FieldName")]
591        pub field_name: ::std::string::String,
592        #[serde(rename = "Help")]
593        pub help: ::std::string::String,
594        #[serde(rename = "Hide")]
595        pub hide: f64,
596        #[serde(rename = "IsPassword")]
597        pub is_password: bool,
598        #[serde(rename = "Name")]
599        pub name: ::std::string::String,
600        #[serde(rename = "NoPrefix")]
601        pub no_prefix: bool,
602        #[serde(
603            rename = "Provider",
604            default,
605            skip_serializing_if = "::std::option::Option::is_none"
606        )]
607        pub provider: ::std::option::Option<::std::string::String>,
608        #[serde(rename = "Required")]
609        pub required: bool,
610        #[serde(rename = "Sensitive")]
611        pub sensitive: bool,
612        #[serde(
613            rename = "ShortOpt",
614            default,
615            skip_serializing_if = "::std::option::Option::is_none"
616        )]
617        pub short_opt: ::std::option::Option<::std::string::String>,
618        #[serde(rename = "Type")]
619        pub type_: ConfigProviderOptionType,
620        #[serde(rename = "Value")]
621        pub value: ConfigProviderOptionAny,
622        #[serde(rename = "ValueStr")]
623        pub value_str: ::std::string::String,
624    }
625
626    impl ::std::convert::From<&ConfigProviderOption> for ConfigProviderOption {
627        fn from(value: &ConfigProviderOption) -> Self {
628            value.clone()
629        }
630    }
631
632    ///Arbitrary JSON value. (arbitrary JSON value)
633    ///
634    /// <details><summary>JSON schema</summary>
635    ///
636    /// ```json
637    ///{
638    ///  "description": "Arbitrary JSON value. (arbitrary JSON value)",
639    ///  "type": [
640    ///    "object",
641    ///    "null"
642    ///  ],
643    ///  "additionalProperties": true
644    ///}
645    /// ```
646    /// </details>
647    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
648    #[serde(transparent)]
649    pub struct ConfigProviderOptionAny(
650        pub ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
651    );
652    impl ::std::ops::Deref for ConfigProviderOptionAny {
653        type Target =
654            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>;
655        fn deref(
656            &self,
657        ) -> &::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
658        {
659            &self.0
660        }
661    }
662
663    impl ::std::convert::From<ConfigProviderOptionAny>
664        for ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
665    {
666        fn from(value: ConfigProviderOptionAny) -> Self {
667            value.0
668        }
669    }
670
671    impl ::std::convert::From<&ConfigProviderOptionAny> for ConfigProviderOptionAny {
672        fn from(value: &ConfigProviderOptionAny) -> Self {
673            value.clone()
674        }
675    }
676
677    impl
678        ::std::convert::From<
679            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
680        > for ConfigProviderOptionAny
681    {
682        fn from(
683            value: ::std::option::Option<
684                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
685            >,
686        ) -> Self {
687            Self(value)
688        }
689    }
690
691    ///`ConfigProviderOptionExample`
692    ///
693    /// <details><summary>JSON schema</summary>
694    ///
695    /// ```json
696    ///{
697    ///  "type": "object",
698    ///  "required": [
699    ///    "Help",
700    ///    "Value"
701    ///  ],
702    ///  "properties": {
703    ///    "Help": {
704    ///      "type": "string"
705    ///    },
706    ///    "Provider": {
707    ///      "type": "string"
708    ///    },
709    ///    "Value": {
710    ///      "type": "string"
711    ///    }
712    ///  },
713    ///  "additionalProperties": true
714    ///}
715    /// ```
716    /// </details>
717    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
718    pub struct ConfigProviderOptionExample {
719        #[serde(rename = "Help")]
720        pub help: ::std::string::String,
721        #[serde(
722            rename = "Provider",
723            default,
724            skip_serializing_if = "::std::option::Option::is_none"
725        )]
726        pub provider: ::std::option::Option<::std::string::String>,
727        #[serde(rename = "Value")]
728        pub value: ::std::string::String,
729    }
730
731    impl ::std::convert::From<&ConfigProviderOptionExample> for ConfigProviderOptionExample {
732        fn from(value: &ConfigProviderOptionExample) -> Self {
733            value.clone()
734        }
735    }
736
737    ///`ConfigProviderOptionType`
738    ///
739    /// <details><summary>JSON schema</summary>
740    ///
741    /// ```json
742    ///{
743    ///  "type": "string",
744    ///  "enum": [
745    ///    "Bits",
746    ///    "bool",
747    ///    "CommaSepList",
748    ///    "Duration",
749    ///    "Encoding",
750    ///    "int",
751    ///    "mtime|atime|btime|ctime",
752    ///    "SizeSuffix",
753    ///    "SpaceSepList",
754    ///    "string",
755    ///    "stringArray",
756    ///    "Time",
757    ///    "Tristate"
758    ///  ]
759    ///}
760    /// ```
761    /// </details>
762    #[derive(
763        :: serde :: Deserialize,
764        :: serde :: Serialize,
765        Clone,
766        Copy,
767        Debug,
768        Eq,
769        Hash,
770        Ord,
771        PartialEq,
772        PartialOrd,
773    )]
774    pub enum ConfigProviderOptionType {
775        Bits,
776        #[serde(rename = "bool")]
777        Bool,
778        CommaSepList,
779        Duration,
780        Encoding,
781        #[serde(rename = "int")]
782        Int,
783        #[serde(rename = "mtime|atime|btime|ctime")]
784        MtimeAtimeBtimeCtime,
785        SizeSuffix,
786        SpaceSepList,
787        #[serde(rename = "string")]
788        String,
789        #[serde(rename = "stringArray")]
790        StringArray,
791        Time,
792        Tristate,
793    }
794
795    impl ::std::convert::From<&Self> for ConfigProviderOptionType {
796        fn from(value: &ConfigProviderOptionType) -> Self {
797            value.clone()
798        }
799    }
800
801    impl ::std::fmt::Display for ConfigProviderOptionType {
802        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
803            match *self {
804                Self::Bits => f.write_str("Bits"),
805                Self::Bool => f.write_str("bool"),
806                Self::CommaSepList => f.write_str("CommaSepList"),
807                Self::Duration => f.write_str("Duration"),
808                Self::Encoding => f.write_str("Encoding"),
809                Self::Int => f.write_str("int"),
810                Self::MtimeAtimeBtimeCtime => f.write_str("mtime|atime|btime|ctime"),
811                Self::SizeSuffix => f.write_str("SizeSuffix"),
812                Self::SpaceSepList => f.write_str("SpaceSepList"),
813                Self::String => f.write_str("string"),
814                Self::StringArray => f.write_str("stringArray"),
815                Self::Time => f.write_str("Time"),
816                Self::Tristate => f.write_str("Tristate"),
817            }
818        }
819    }
820
821    impl ::std::str::FromStr for ConfigProviderOptionType {
822        type Err = self::error::ConversionError;
823        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
824            match value {
825                "Bits" => Ok(Self::Bits),
826                "bool" => Ok(Self::Bool),
827                "CommaSepList" => Ok(Self::CommaSepList),
828                "Duration" => Ok(Self::Duration),
829                "Encoding" => Ok(Self::Encoding),
830                "int" => Ok(Self::Int),
831                "mtime|atime|btime|ctime" => Ok(Self::MtimeAtimeBtimeCtime),
832                "SizeSuffix" => Ok(Self::SizeSuffix),
833                "SpaceSepList" => Ok(Self::SpaceSepList),
834                "string" => Ok(Self::String),
835                "stringArray" => Ok(Self::StringArray),
836                "Time" => Ok(Self::Time),
837                "Tristate" => Ok(Self::Tristate),
838                _ => Err("invalid value".into()),
839            }
840        }
841    }
842
843    impl ::std::convert::TryFrom<&str> for ConfigProviderOptionType {
844        type Error = self::error::ConversionError;
845        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
846            value.parse()
847        }
848    }
849
850    impl ::std::convert::TryFrom<&::std::string::String> for ConfigProviderOptionType {
851        type Error = self::error::ConversionError;
852        fn try_from(
853            value: &::std::string::String,
854        ) -> ::std::result::Result<Self, self::error::ConversionError> {
855            value.parse()
856        }
857    }
858
859    impl ::std::convert::TryFrom<::std::string::String> for ConfigProviderOptionType {
860        type Error = self::error::ConversionError;
861        fn try_from(
862            value: ::std::string::String,
863        ) -> ::std::result::Result<Self, self::error::ConversionError> {
864            value.parse()
865        }
866    }
867
868    ///`ConfigProvidersResponse`
869    ///
870    /// <details><summary>JSON schema</summary>
871    ///
872    /// ```json
873    ///{
874    ///  "type": "object",
875    ///  "required": [
876    ///    "providers"
877    ///  ],
878    ///  "properties": {
879    ///    "providers": {
880    ///      "type": "array",
881    ///      "items": {
882    ///        "$ref": "#/components/schemas/ConfigProvider"
883    ///      }
884    ///    }
885    ///  },
886    ///  "additionalProperties": true
887    ///}
888    /// ```
889    /// </details>
890    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
891    pub struct ConfigProvidersResponse {
892        pub providers: ::std::vec::Vec<ConfigProvider>,
893    }
894
895    impl ::std::convert::From<&ConfigProvidersResponse> for ConfigProvidersResponse {
896        fn from(value: &ConfigProvidersResponse) -> Self {
897            value.clone()
898        }
899    }
900
901    ///`CoreBwlimitResponse`
902    ///
903    /// <details><summary>JSON schema</summary>
904    ///
905    /// ```json
906    ///{
907    ///  "type": "object",
908    ///  "required": [
909    ///    "bytesPerSecond",
910    ///    "bytesPerSecondRx",
911    ///    "bytesPerSecondTx",
912    ///    "rate"
913    ///  ],
914    ///  "properties": {
915    ///    "bytesPerSecond": {
916    ///      "type": "integer"
917    ///    },
918    ///    "bytesPerSecondRx": {
919    ///      "type": "integer"
920    ///    },
921    ///    "bytesPerSecondTx": {
922    ///      "type": "integer"
923    ///    },
924    ///    "rate": {
925    ///      "type": "string"
926    ///    }
927    ///  }
928    ///}
929    /// ```
930    /// </details>
931    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
932    pub struct CoreBwlimitResponse {
933        #[serde(rename = "bytesPerSecond")]
934        pub bytes_per_second: i64,
935        #[serde(rename = "bytesPerSecondRx")]
936        pub bytes_per_second_rx: i64,
937        #[serde(rename = "bytesPerSecondTx")]
938        pub bytes_per_second_tx: i64,
939        pub rate: ::std::string::String,
940    }
941
942    impl ::std::convert::From<&CoreBwlimitResponse> for CoreBwlimitResponse {
943        fn from(value: &CoreBwlimitResponse) -> Self {
944            value.clone()
945        }
946    }
947
948    ///`CoreCommandResponse`
949    ///
950    /// <details><summary>JSON schema</summary>
951    ///
952    /// ```json
953    ///{
954    ///  "type": "object",
955    ///  "required": [
956    ///    "error"
957    ///  ],
958    ///  "properties": {
959    ///    "error": {
960    ///      "type": "boolean"
961    ///    },
962    ///    "result": {
963    ///      "type": [
964    ///        "string",
965    ///        "null"
966    ///      ]
967    ///    },
968    ///    "returnType": {
969    ///      "type": [
970    ///        "string",
971    ///        "null"
972    ///      ]
973    ///    }
974    ///  }
975    ///}
976    /// ```
977    /// </details>
978    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
979    pub struct CoreCommandResponse {
980        pub error: bool,
981        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
982        pub result: ::std::option::Option<::std::string::String>,
983        #[serde(
984            rename = "returnType",
985            default,
986            skip_serializing_if = "::std::option::Option::is_none"
987        )]
988        pub return_type: ::std::option::Option<::std::string::String>,
989    }
990
991    impl ::std::convert::From<&CoreCommandResponse> for CoreCommandResponse {
992        fn from(value: &CoreCommandResponse) -> Self {
993            value.clone()
994        }
995    }
996
997    ///`CoreDuResponse`
998    ///
999    /// <details><summary>JSON schema</summary>
1000    ///
1001    /// ```json
1002    ///{
1003    ///  "type": "object",
1004    ///  "required": [
1005    ///    "dir",
1006    ///    "info"
1007    ///  ],
1008    ///  "properties": {
1009    ///    "dir": {
1010    ///      "type": "string"
1011    ///    },
1012    ///    "info": {
1013    ///      "type": "object",
1014    ///      "required": [
1015    ///        "Available",
1016    ///        "Free",
1017    ///        "Total"
1018    ///      ],
1019    ///      "properties": {
1020    ///        "Available": {
1021    ///          "type": "integer"
1022    ///        },
1023    ///        "Free": {
1024    ///          "type": "integer"
1025    ///        },
1026    ///        "Total": {
1027    ///          "type": "integer"
1028    ///        }
1029    ///      }
1030    ///    }
1031    ///  }
1032    ///}
1033    /// ```
1034    /// </details>
1035    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1036    pub struct CoreDuResponse {
1037        pub dir: ::std::string::String,
1038        pub info: CoreDuResponseInfo,
1039    }
1040
1041    impl ::std::convert::From<&CoreDuResponse> for CoreDuResponse {
1042        fn from(value: &CoreDuResponse) -> Self {
1043            value.clone()
1044        }
1045    }
1046
1047    ///`CoreDuResponseInfo`
1048    ///
1049    /// <details><summary>JSON schema</summary>
1050    ///
1051    /// ```json
1052    ///{
1053    ///  "type": "object",
1054    ///  "required": [
1055    ///    "Available",
1056    ///    "Free",
1057    ///    "Total"
1058    ///  ],
1059    ///  "properties": {
1060    ///    "Available": {
1061    ///      "type": "integer"
1062    ///    },
1063    ///    "Free": {
1064    ///      "type": "integer"
1065    ///    },
1066    ///    "Total": {
1067    ///      "type": "integer"
1068    ///    }
1069    ///  }
1070    ///}
1071    /// ```
1072    /// </details>
1073    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1074    pub struct CoreDuResponseInfo {
1075        #[serde(rename = "Available")]
1076        pub available: i64,
1077        #[serde(rename = "Free")]
1078        pub free: i64,
1079        #[serde(rename = "Total")]
1080        pub total: i64,
1081    }
1082
1083    impl ::std::convert::From<&CoreDuResponseInfo> for CoreDuResponseInfo {
1084        fn from(value: &CoreDuResponseInfo) -> Self {
1085            value.clone()
1086        }
1087    }
1088
1089    ///`CoreGroupListResponse`
1090    ///
1091    /// <details><summary>JSON schema</summary>
1092    ///
1093    /// ```json
1094    ///{
1095    ///  "type": "object",
1096    ///  "required": [
1097    ///    "groups"
1098    ///  ],
1099    ///  "properties": {
1100    ///    "groups": {
1101    ///      "type": "array",
1102    ///      "items": {
1103    ///        "type": "string"
1104    ///      }
1105    ///    }
1106    ///  }
1107    ///}
1108    /// ```
1109    /// </details>
1110    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1111    pub struct CoreGroupListResponse {
1112        pub groups: ::std::vec::Vec<::std::string::String>,
1113    }
1114
1115    impl ::std::convert::From<&CoreGroupListResponse> for CoreGroupListResponse {
1116        fn from(value: &CoreGroupListResponse) -> Self {
1117            value.clone()
1118        }
1119    }
1120
1121    ///`CoreObscureResponse`
1122    ///
1123    /// <details><summary>JSON schema</summary>
1124    ///
1125    /// ```json
1126    ///{
1127    ///  "type": "object",
1128    ///  "required": [
1129    ///    "obscured"
1130    ///  ],
1131    ///  "properties": {
1132    ///    "obscured": {
1133    ///      "type": "string"
1134    ///    }
1135    ///  }
1136    ///}
1137    /// ```
1138    /// </details>
1139    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1140    pub struct CoreObscureResponse {
1141        pub obscured: ::std::string::String,
1142    }
1143
1144    impl ::std::convert::From<&CoreObscureResponse> for CoreObscureResponse {
1145        fn from(value: &CoreObscureResponse) -> Self {
1146            value.clone()
1147        }
1148    }
1149
1150    ///`CorePidResponse`
1151    ///
1152    /// <details><summary>JSON schema</summary>
1153    ///
1154    /// ```json
1155    ///{
1156    ///  "type": "object",
1157    ///  "required": [
1158    ///    "pid"
1159    ///  ],
1160    ///  "properties": {
1161    ///    "pid": {
1162    ///      "type": "integer"
1163    ///    }
1164    ///  }
1165    ///}
1166    /// ```
1167    /// </details>
1168    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1169    pub struct CorePidResponse {
1170        pub pid: i64,
1171    }
1172
1173    impl ::std::convert::From<&CorePidResponse> for CorePidResponse {
1174        fn from(value: &CorePidResponse) -> Self {
1175            value.clone()
1176        }
1177    }
1178
1179    ///Metadata for an item currently undergoing verification.
1180    ///
1181    /// <details><summary>JSON schema</summary>
1182    ///
1183    /// ```json
1184    ///{
1185    ///  "description": "Metadata for an item currently undergoing
1186    /// verification.",
1187    ///  "type": "object",
1188    ///  "properties": {
1189    ///    "group": {
1190    ///      "description": "Stats group name associated with this
1191    /// verification.",
1192    ///      "type": "string"
1193    ///    },
1194    ///    "name": {
1195    ///      "description": "Remote path of the object being verified.",
1196    ///      "type": "string"
1197    ///    },
1198    ///    "size": {
1199    ///      "description": "Total size in bytes of the object.",
1200    ///      "type": "number"
1201    ///    }
1202    ///  },
1203    ///  "additionalProperties": true
1204    ///}
1205    /// ```
1206    /// </details>
1207    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1208    pub struct CoreStatsChecking {
1209        ///Stats group name associated with this verification.
1210        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1211        pub group: ::std::option::Option<::std::string::String>,
1212        ///Remote path of the object being verified.
1213        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1214        pub name: ::std::option::Option<::std::string::String>,
1215        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1216        pub size: ::std::option::Option<f64>,
1217    }
1218
1219    impl ::std::convert::From<&CoreStatsChecking> for CoreStatsChecking {
1220        fn from(value: &CoreStatsChecking) -> Self {
1221            value.clone()
1222        }
1223    }
1224
1225    impl ::std::default::Default for CoreStatsChecking {
1226        fn default() -> Self {
1227            Self {
1228                group: Default::default(),
1229                name: Default::default(),
1230                size: Default::default(),
1231            }
1232        }
1233    }
1234
1235    ///`CoreStatsResponse`
1236    ///
1237    /// <details><summary>JSON schema</summary>
1238    ///
1239    /// ```json
1240    ///{
1241    ///  "type": "object",
1242    ///  "required": [
1243    ///    "bytes",
1244    ///    "checks",
1245    ///    "deletedDirs",
1246    ///    "deletes",
1247    ///    "elapsedTime",
1248    ///    "errors",
1249    ///    "eta",
1250    ///    "fatalError",
1251    ///    "renames",
1252    ///    "retryError",
1253    ///    "serverSideCopies",
1254    ///    "serverSideCopyBytes",
1255    ///    "serverSideMoveBytes",
1256    ///    "serverSideMoves",
1257    ///    "speed",
1258    ///    "totalBytes",
1259    ///    "totalChecks",
1260    ///    "totalTransfers",
1261    ///    "transferTime",
1262    ///    "transfers"
1263    ///  ],
1264    ///  "properties": {
1265    ///    "bytes": {
1266    ///      "type": "number"
1267    ///    },
1268    ///    "checking": {
1269    ///      "description": "Objects currently undergoing verification
1270    /// operations.",
1271    ///      "type": "array",
1272    ///      "items": {
1273    ///        "$ref": "#/components/schemas/CoreStatsChecking"
1274    ///      }
1275    ///    },
1276    ///    "checks": {
1277    ///      "type": "number"
1278    ///    },
1279    ///    "deletedDirs": {
1280    ///      "type": "number"
1281    ///    },
1282    ///    "deletes": {
1283    ///      "type": "number"
1284    ///    },
1285    ///    "elapsedTime": {
1286    ///      "type": "number"
1287    ///    },
1288    ///    "errors": {
1289    ///      "type": "number"
1290    ///    },
1291    ///    "eta": {
1292    ///      "type": [
1293    ///        "number",
1294    ///        "null"
1295    ///      ]
1296    ///    },
1297    ///    "fatalError": {
1298    ///      "type": "boolean"
1299    ///    },
1300    ///    "lastError": {
1301    ///      "type": "string"
1302    ///    },
1303    ///    "renames": {
1304    ///      "type": "number"
1305    ///    },
1306    ///    "retryError": {
1307    ///      "type": "boolean"
1308    ///    },
1309    ///    "serverSideCopies": {
1310    ///      "type": "number"
1311    ///    },
1312    ///    "serverSideCopyBytes": {
1313    ///      "type": "number"
1314    ///    },
1315    ///    "serverSideMoveBytes": {
1316    ///      "type": "number"
1317    ///    },
1318    ///    "serverSideMoves": {
1319    ///      "type": "number"
1320    ///    },
1321    ///    "speed": {
1322    ///      "type": "number"
1323    ///    },
1324    ///    "totalBytes": {
1325    ///      "type": "number"
1326    ///    },
1327    ///    "totalChecks": {
1328    ///      "type": "number"
1329    ///    },
1330    ///    "totalTransfers": {
1331    ///      "type": "number"
1332    ///    },
1333    ///    "transferTime": {
1334    ///      "type": "number"
1335    ///    },
1336    ///    "transferring": {
1337    ///      "description": "Active transfers currently in progress grouped by
1338    /// stats group.",
1339    ///      "type": "array",
1340    ///      "items": {
1341    ///        "$ref": "#/components/schemas/CoreStatsTransfer"
1342    ///      }
1343    ///    },
1344    ///    "transfers": {
1345    ///      "type": "number"
1346    ///    }
1347    ///  }
1348    ///}
1349    /// ```
1350    /// </details>
1351    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1352    pub struct CoreStatsResponse {
1353        pub bytes: f64,
1354        ///Objects currently undergoing verification operations.
1355        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1356        pub checking: ::std::vec::Vec<CoreStatsChecking>,
1357        pub checks: f64,
1358        #[serde(rename = "deletedDirs")]
1359        pub deleted_dirs: f64,
1360        pub deletes: f64,
1361        #[serde(rename = "elapsedTime")]
1362        pub elapsed_time: f64,
1363        pub errors: f64,
1364        pub eta: ::std::option::Option<f64>,
1365        #[serde(rename = "fatalError")]
1366        pub fatal_error: bool,
1367        #[serde(
1368            rename = "lastError",
1369            default,
1370            skip_serializing_if = "::std::option::Option::is_none"
1371        )]
1372        pub last_error: ::std::option::Option<::std::string::String>,
1373        pub renames: f64,
1374        #[serde(rename = "retryError")]
1375        pub retry_error: bool,
1376        #[serde(rename = "serverSideCopies")]
1377        pub server_side_copies: f64,
1378        #[serde(rename = "serverSideCopyBytes")]
1379        pub server_side_copy_bytes: f64,
1380        #[serde(rename = "serverSideMoveBytes")]
1381        pub server_side_move_bytes: f64,
1382        #[serde(rename = "serverSideMoves")]
1383        pub server_side_moves: f64,
1384        pub speed: f64,
1385        #[serde(rename = "totalBytes")]
1386        pub total_bytes: f64,
1387        #[serde(rename = "totalChecks")]
1388        pub total_checks: f64,
1389        #[serde(rename = "totalTransfers")]
1390        pub total_transfers: f64,
1391        #[serde(rename = "transferTime")]
1392        pub transfer_time: f64,
1393        ///Active transfers currently in progress grouped by stats group.
1394        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1395        pub transferring: ::std::vec::Vec<CoreStatsTransfer>,
1396        pub transfers: f64,
1397    }
1398
1399    impl ::std::convert::From<&CoreStatsResponse> for CoreStatsResponse {
1400        fn from(value: &CoreStatsResponse) -> Self {
1401            value.clone()
1402        }
1403    }
1404
1405    ///Progress metrics for an in-flight transfer.
1406    ///
1407    /// <details><summary>JSON schema</summary>
1408    ///
1409    /// ```json
1410    ///{
1411    ///  "description": "Progress metrics for an in-flight transfer.",
1412    ///  "type": "object",
1413    ///  "properties": {
1414    ///    "bytes": {
1415    ///      "description": "Bytes transferred so far for this object.",
1416    ///      "type": "number"
1417    ///    },
1418    ///    "eta": {
1419    ///      "description": "Estimated seconds remaining, when available.",
1420    ///      "type": [
1421    ///        "number",
1422    ///        "null"
1423    ///      ]
1424    ///    },
1425    ///    "group": {
1426    ///      "description": "Stats group name associated with this transfer.",
1427    ///      "type": "string"
1428    ///    },
1429    ///    "name": {
1430    ///      "description": "Remote path of the object being transferred.",
1431    ///      "type": "string"
1432    ///    },
1433    ///    "percentage": {
1434    ///      "description": "Completion percentage from 0-100.",
1435    ///      "type": "number"
1436    ///    },
1437    ///    "size": {
1438    ///      "description": "Total size in bytes of the object.",
1439    ///      "type": "number"
1440    ///    },
1441    ///    "speed": {
1442    ///      "description": "Current transfer speed in bytes per second.",
1443    ///      "type": "number"
1444    ///    }
1445    ///  },
1446    ///  "additionalProperties": true
1447    ///}
1448    /// ```
1449    /// </details>
1450    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1451    pub struct CoreStatsTransfer {
1452        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1453        pub bytes: ::std::option::Option<f64>,
1454        ///Estimated seconds remaining, when available.
1455        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1456        pub eta: ::std::option::Option<f64>,
1457        ///Stats group name associated with this transfer.
1458        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1459        pub group: ::std::option::Option<::std::string::String>,
1460        ///Remote path of the object being transferred.
1461        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1462        pub name: ::std::option::Option<::std::string::String>,
1463        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1464        pub percentage: ::std::option::Option<f64>,
1465        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1466        pub size: ::std::option::Option<f64>,
1467        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1468        pub speed: ::std::option::Option<f64>,
1469    }
1470
1471    impl ::std::convert::From<&CoreStatsTransfer> for CoreStatsTransfer {
1472        fn from(value: &CoreStatsTransfer) -> Self {
1473            value.clone()
1474        }
1475    }
1476
1477    impl ::std::default::Default for CoreStatsTransfer {
1478        fn default() -> Self {
1479            Self {
1480                bytes: Default::default(),
1481                eta: Default::default(),
1482                group: Default::default(),
1483                name: Default::default(),
1484                percentage: Default::default(),
1485                size: Default::default(),
1486                speed: Default::default(),
1487            }
1488        }
1489    }
1490
1491    ///`CoreTransferredResponse`
1492    ///
1493    /// <details><summary>JSON schema</summary>
1494    ///
1495    /// ```json
1496    ///{
1497    ///  "type": "object",
1498    ///  "required": [
1499    ///    "transferred"
1500    ///  ],
1501    ///  "properties": {
1502    ///    "transferred": {
1503    ///      "type": "array",
1504    ///      "items": {
1505    ///        "type": "object",
1506    ///        "required": [
1507    ///          "group"
1508    ///        ],
1509    ///        "properties": {
1510    ///          "bytes": {
1511    ///            "type": "integer"
1512    ///          },
1513    ///          "checked": {
1514    ///            "type": "boolean"
1515    ///          },
1516    ///          "completed_at": {
1517    ///            "description": "ISO8601 timestamp when the transfer
1518    /// completed.",
1519    ///            "type": "string"
1520    ///          },
1521    ///          "dstFs": {
1522    ///            "description": "Destination remote or filesystem used for the
1523    /// transfer.",
1524    ///            "type": "string"
1525    ///          },
1526    ///          "dstRemote": {
1527    ///            "description": "Destination path within `dstFs`, when
1528    /// provided.",
1529    ///            "type": "string"
1530    ///          },
1531    ///          "error": {
1532    ///            "type": "string"
1533    ///          },
1534    ///          "group": {
1535    ///            "description": "Stats group identifier this transfer belonged
1536    /// to.",
1537    ///            "type": "string"
1538    ///          },
1539    ///          "jobid": {
1540    ///            "type": "integer"
1541    ///          },
1542    ///          "name": {
1543    ///            "type": "string"
1544    ///          },
1545    ///          "size": {
1546    ///            "type": "integer"
1547    ///          },
1548    ///          "srcFs": {
1549    ///            "description": "Source remote or filesystem used for the
1550    /// transfer.",
1551    ///            "type": "string"
1552    ///          },
1553    ///          "srcRemote": {
1554    ///            "description": "Source path within `srcFs`, when provided.",
1555    ///            "type": "string"
1556    ///          },
1557    ///          "started_at": {
1558    ///            "description": "ISO8601 timestamp when the transfer
1559    /// started.",
1560    ///            "type": "string"
1561    ///          },
1562    ///          "timestamp": {
1563    ///            "type": "integer"
1564    ///          },
1565    ///          "what": {
1566    ///            "type": "string"
1567    ///          }
1568    ///        },
1569    ///        "additionalProperties": true
1570    ///      }
1571    ///    }
1572    ///  }
1573    ///}
1574    /// ```
1575    /// </details>
1576    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1577    pub struct CoreTransferredResponse {
1578        pub transferred: ::std::vec::Vec<CoreTransferredResponseTransferredItem>,
1579    }
1580
1581    impl ::std::convert::From<&CoreTransferredResponse> for CoreTransferredResponse {
1582        fn from(value: &CoreTransferredResponse) -> Self {
1583            value.clone()
1584        }
1585    }
1586
1587    ///`CoreTransferredResponseTransferredItem`
1588    ///
1589    /// <details><summary>JSON schema</summary>
1590    ///
1591    /// ```json
1592    ///{
1593    ///  "type": "object",
1594    ///  "required": [
1595    ///    "group"
1596    ///  ],
1597    ///  "properties": {
1598    ///    "bytes": {
1599    ///      "type": "integer"
1600    ///    },
1601    ///    "checked": {
1602    ///      "type": "boolean"
1603    ///    },
1604    ///    "completed_at": {
1605    ///      "description": "ISO8601 timestamp when the transfer completed.",
1606    ///      "type": "string"
1607    ///    },
1608    ///    "dstFs": {
1609    ///      "description": "Destination remote or filesystem used for the
1610    /// transfer.",
1611    ///      "type": "string"
1612    ///    },
1613    ///    "dstRemote": {
1614    ///      "description": "Destination path within `dstFs`, when provided.",
1615    ///      "type": "string"
1616    ///    },
1617    ///    "error": {
1618    ///      "type": "string"
1619    ///    },
1620    ///    "group": {
1621    ///      "description": "Stats group identifier this transfer belonged to.",
1622    ///      "type": "string"
1623    ///    },
1624    ///    "jobid": {
1625    ///      "type": "integer"
1626    ///    },
1627    ///    "name": {
1628    ///      "type": "string"
1629    ///    },
1630    ///    "size": {
1631    ///      "type": "integer"
1632    ///    },
1633    ///    "srcFs": {
1634    ///      "description": "Source remote or filesystem used for the
1635    /// transfer.",
1636    ///      "type": "string"
1637    ///    },
1638    ///    "srcRemote": {
1639    ///      "description": "Source path within `srcFs`, when provided.",
1640    ///      "type": "string"
1641    ///    },
1642    ///    "started_at": {
1643    ///      "description": "ISO8601 timestamp when the transfer started.",
1644    ///      "type": "string"
1645    ///    },
1646    ///    "timestamp": {
1647    ///      "type": "integer"
1648    ///    },
1649    ///    "what": {
1650    ///      "type": "string"
1651    ///    }
1652    ///  },
1653    ///  "additionalProperties": true
1654    ///}
1655    /// ```
1656    /// </details>
1657    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1658    pub struct CoreTransferredResponseTransferredItem {
1659        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1660        pub bytes: ::std::option::Option<i64>,
1661        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1662        pub checked: ::std::option::Option<bool>,
1663        ///ISO8601 timestamp when the transfer completed.
1664        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1665        pub completed_at: ::std::option::Option<::std::string::String>,
1666        ///Destination remote or filesystem used for the transfer.
1667        #[serde(
1668            rename = "dstFs",
1669            default,
1670            skip_serializing_if = "::std::option::Option::is_none"
1671        )]
1672        pub dst_fs: ::std::option::Option<::std::string::String>,
1673        ///Destination path within `dstFs`, when provided.
1674        #[serde(
1675            rename = "dstRemote",
1676            default,
1677            skip_serializing_if = "::std::option::Option::is_none"
1678        )]
1679        pub dst_remote: ::std::option::Option<::std::string::String>,
1680        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1681        pub error: ::std::option::Option<::std::string::String>,
1682        ///Stats group identifier this transfer belonged to.
1683        pub group: ::std::string::String,
1684        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1685        pub jobid: ::std::option::Option<i64>,
1686        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1687        pub name: ::std::option::Option<::std::string::String>,
1688        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1689        pub size: ::std::option::Option<i64>,
1690        ///Source remote or filesystem used for the transfer.
1691        #[serde(
1692            rename = "srcFs",
1693            default,
1694            skip_serializing_if = "::std::option::Option::is_none"
1695        )]
1696        pub src_fs: ::std::option::Option<::std::string::String>,
1697        ///Source path within `srcFs`, when provided.
1698        #[serde(
1699            rename = "srcRemote",
1700            default,
1701            skip_serializing_if = "::std::option::Option::is_none"
1702        )]
1703        pub src_remote: ::std::option::Option<::std::string::String>,
1704        ///ISO8601 timestamp when the transfer started.
1705        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1706        pub started_at: ::std::option::Option<::std::string::String>,
1707        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1708        pub timestamp: ::std::option::Option<i64>,
1709        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1710        pub what: ::std::option::Option<::std::string::String>,
1711    }
1712
1713    impl ::std::convert::From<&CoreTransferredResponseTransferredItem>
1714        for CoreTransferredResponseTransferredItem
1715    {
1716        fn from(value: &CoreTransferredResponseTransferredItem) -> Self {
1717            value.clone()
1718        }
1719    }
1720
1721    ///`CoreVersionResponse`
1722    ///
1723    /// <details><summary>JSON schema</summary>
1724    ///
1725    /// ```json
1726    ///{
1727    ///  "type": "object",
1728    ///  "required": [
1729    ///    "arch",
1730    ///    "decomposed",
1731    ///    "goTags",
1732    ///    "goVersion",
1733    ///    "isBeta",
1734    ///    "isGit",
1735    ///    "linking",
1736    ///    "os",
1737    ///    "version"
1738    ///  ],
1739    ///  "properties": {
1740    ///    "arch": {
1741    ///      "description": "CPU architecture (e.g. amd64, arm64).",
1742    ///      "type": "string"
1743    ///    },
1744    ///    "decomposed": {
1745    ///      "description": "Version number broken into components.",
1746    ///      "type": "array",
1747    ///      "items": {
1748    ///        "type": "number"
1749    ///      }
1750    ///    },
1751    ///    "goTags": {
1752    ///      "description": "Space separated Go build tags, if any.",
1753    ///      "type": "string"
1754    ///    },
1755    ///    "goVersion": {
1756    ///      "description": "Go toolchain version used to build rclone.",
1757    ///      "type": "string"
1758    ///    },
1759    ///    "isBeta": {
1760    ///      "description": "Indicates whether this build is a beta version.",
1761    ///      "type": "boolean"
1762    ///    },
1763    ///    "isGit": {
1764    ///      "description": "True when built directly from a git checkout.",
1765    ///      "type": "boolean"
1766    ///    },
1767    ///    "linking": {
1768    ///      "description": "Linking mode for the binary (static or dynamic).",
1769    ///      "type": "string"
1770    ///    },
1771    ///    "os": {
1772    ///      "description": "Operating system rclone is running on (e.g. linux,
1773    /// darwin).",
1774    ///      "type": "string"
1775    ///    },
1776    ///    "osArch": {
1777    ///      "description": "CPU architecture in use (e.g. arm64 (ARMv8
1778    /// compatible)).",
1779    ///      "type": "string"
1780    ///    },
1781    ///    "osKernel": {
1782    ///      "description": "OS Kernel version (e.g. 6.8.0-86-generic
1783    /// (x86_64)).",
1784    ///      "type": "string"
1785    ///    },
1786    ///    "osVersion": {
1787    ///      "description": "OS Version (e.g. ubuntu 24.04 (64 bit)).",
1788    ///      "type": "string"
1789    ///    },
1790    ///    "version": {
1791    ///      "description": "Full semantic version string (e.g. 1.67.0).",
1792    ///      "type": "string"
1793    ///    }
1794    ///  }
1795    ///}
1796    /// ```
1797    /// </details>
1798    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1799    pub struct CoreVersionResponse {
1800        ///CPU architecture (e.g. amd64, arm64).
1801        pub arch: ::std::string::String,
1802        ///Version number broken into components.
1803        pub decomposed: ::std::vec::Vec<f64>,
1804        ///Space separated Go build tags, if any.
1805        #[serde(rename = "goTags")]
1806        pub go_tags: ::std::string::String,
1807        ///Go toolchain version used to build rclone.
1808        #[serde(rename = "goVersion")]
1809        pub go_version: ::std::string::String,
1810        ///Indicates whether this build is a beta version.
1811        #[serde(rename = "isBeta")]
1812        pub is_beta: bool,
1813        ///True when built directly from a git checkout.
1814        #[serde(rename = "isGit")]
1815        pub is_git: bool,
1816        ///Linking mode for the binary (static or dynamic).
1817        pub linking: ::std::string::String,
1818        ///Operating system rclone is running on (e.g. linux, darwin).
1819        pub os: ::std::string::String,
1820        ///CPU architecture in use (e.g. arm64 (ARMv8 compatible)).
1821        #[serde(
1822            rename = "osArch",
1823            default,
1824            skip_serializing_if = "::std::option::Option::is_none"
1825        )]
1826        pub os_arch: ::std::option::Option<::std::string::String>,
1827        ///OS Kernel version (e.g. 6.8.0-86-generic (x86_64)).
1828        #[serde(
1829            rename = "osKernel",
1830            default,
1831            skip_serializing_if = "::std::option::Option::is_none"
1832        )]
1833        pub os_kernel: ::std::option::Option<::std::string::String>,
1834        ///OS Version (e.g. ubuntu 24.04 (64 bit)).
1835        #[serde(
1836            rename = "osVersion",
1837            default,
1838            skip_serializing_if = "::std::option::Option::is_none"
1839        )]
1840        pub os_version: ::std::option::Option<::std::string::String>,
1841        ///Full semantic version string (e.g. 1.67.0).
1842        pub version: ::std::string::String,
1843    }
1844
1845    impl ::std::convert::From<&CoreVersionResponse> for CoreVersionResponse {
1846        fn from(value: &CoreVersionResponse) -> Self {
1847            value.clone()
1848        }
1849    }
1850
1851    ///`DebugSetGcPercentResponse`
1852    ///
1853    /// <details><summary>JSON schema</summary>
1854    ///
1855    /// ```json
1856    ///{
1857    ///  "type": "object",
1858    ///  "required": [
1859    ///    "existing-gc-percent"
1860    ///  ],
1861    ///  "properties": {
1862    ///    "existing-gc-percent": {
1863    ///      "type": "integer"
1864    ///    }
1865    ///  }
1866    ///}
1867    /// ```
1868    /// </details>
1869    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1870    pub struct DebugSetGcPercentResponse {
1871        #[serde(rename = "existing-gc-percent")]
1872        pub existing_gc_percent: i64,
1873    }
1874
1875    impl ::std::convert::From<&DebugSetGcPercentResponse> for DebugSetGcPercentResponse {
1876        fn from(value: &DebugSetGcPercentResponse) -> Self {
1877            value.clone()
1878        }
1879    }
1880
1881    ///`DebugSetMutexProfileFractionResponse`
1882    ///
1883    /// <details><summary>JSON schema</summary>
1884    ///
1885    /// ```json
1886    ///{
1887    ///  "type": "object",
1888    ///  "required": [
1889    ///    "previousRate"
1890    ///  ],
1891    ///  "properties": {
1892    ///    "previousRate": {
1893    ///      "type": "integer"
1894    ///    }
1895    ///  }
1896    ///}
1897    /// ```
1898    /// </details>
1899    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1900    pub struct DebugSetMutexProfileFractionResponse {
1901        #[serde(rename = "previousRate")]
1902        pub previous_rate: i64,
1903    }
1904
1905    impl ::std::convert::From<&DebugSetMutexProfileFractionResponse>
1906        for DebugSetMutexProfileFractionResponse
1907    {
1908        fn from(value: &DebugSetMutexProfileFractionResponse) -> Self {
1909            value.clone()
1910        }
1911    }
1912
1913    ///`DebugSetSoftMemoryLimitResponse`
1914    ///
1915    /// <details><summary>JSON schema</summary>
1916    ///
1917    /// ```json
1918    ///{
1919    ///  "type": "object",
1920    ///  "required": [
1921    ///    "existing-mem-limit"
1922    ///  ],
1923    ///  "properties": {
1924    ///    "existing-mem-limit": {
1925    ///      "type": "integer"
1926    ///    }
1927    ///  }
1928    ///}
1929    /// ```
1930    /// </details>
1931    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1932    pub struct DebugSetSoftMemoryLimitResponse {
1933        #[serde(rename = "existing-mem-limit")]
1934        pub existing_mem_limit: i64,
1935    }
1936
1937    impl ::std::convert::From<&DebugSetSoftMemoryLimitResponse> for DebugSetSoftMemoryLimitResponse {
1938        fn from(value: &DebugSetSoftMemoryLimitResponse) -> Self {
1939            value.clone()
1940        }
1941    }
1942
1943    ///`FscacheEntriesResponse`
1944    ///
1945    /// <details><summary>JSON schema</summary>
1946    ///
1947    /// ```json
1948    ///{
1949    ///  "type": "object",
1950    ///  "required": [
1951    ///    "entries"
1952    ///  ],
1953    ///  "properties": {
1954    ///    "entries": {
1955    ///      "type": "integer"
1956    ///    }
1957    ///  }
1958    ///}
1959    /// ```
1960    /// </details>
1961    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1962    pub struct FscacheEntriesResponse {
1963        pub entries: i64,
1964    }
1965
1966    impl ::std::convert::From<&FscacheEntriesResponse> for FscacheEntriesResponse {
1967        fn from(value: &FscacheEntriesResponse) -> Self {
1968            value.clone()
1969        }
1970    }
1971
1972    ///`JobBatchInputsItem`
1973    ///
1974    /// <details><summary>JSON schema</summary>
1975    ///
1976    /// ```json
1977    ///{
1978    ///  "type": "object",
1979    ///  "required": [
1980    ///    "_path"
1981    ///  ],
1982    ///  "properties": {
1983    ///    "_path": {
1984    ///      "description": "rc/path",
1985    ///      "type": "string"
1986    ///    }
1987    ///  },
1988    ///  "additionalProperties": true
1989    ///}
1990    /// ```
1991    /// </details>
1992    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1993    pub struct JobBatchInputsItem {
1994        ///rc/path
1995        #[serde(rename = "_path")]
1996        pub path: ::std::string::String,
1997    }
1998
1999    impl ::std::convert::From<&JobBatchInputsItem> for JobBatchInputsItem {
2000        fn from(value: &JobBatchInputsItem) -> Self {
2001            value.clone()
2002        }
2003    }
2004
2005    ///`JobBatchRequest`
2006    ///
2007    /// <details><summary>JSON schema</summary>
2008    ///
2009    /// ```json
2010    ///{
2011    ///  "type": "object",
2012    ///  "properties": {
2013    ///    "_async": {
2014    ///      "description": "Run the command asynchronously. Returns a job id
2015    /// immediately.",
2016    ///      "type": "boolean"
2017    ///    },
2018    ///    "concurrency": {
2019    ///      "description": "Do this many commands concurrently. Defaults to
2020    /// --transfers if not set.",
2021    ///      "type": "integer"
2022    ///    },
2023    ///    "inputs": {
2024    ///      "description": "List of inputs to the commands with an extra _path
2025    /// parameter.",
2026    ///      "type": "array",
2027    ///      "items": {
2028    ///        "type": "object",
2029    ///        "required": [
2030    ///          "_path"
2031    ///        ],
2032    ///        "properties": {
2033    ///          "_path": {
2034    ///            "description": "rc/path",
2035    ///            "type": "string"
2036    ///          }
2037    ///        },
2038    ///        "additionalProperties": true
2039    ///      }
2040    ///    }
2041    ///  }
2042    ///}
2043    /// ```
2044    /// </details>
2045    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2046    pub struct JobBatchRequest {
2047        ///Run the command asynchronously. Returns a job id immediately.
2048        #[serde(
2049            rename = "_async",
2050            default,
2051            skip_serializing_if = "::std::option::Option::is_none"
2052        )]
2053        pub async_: ::std::option::Option<bool>,
2054        ///Do this many commands concurrently. Defaults to --transfers if not
2055        /// set.
2056        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2057        pub concurrency: ::std::option::Option<i64>,
2058        ///List of inputs to the commands with an extra _path parameter.
2059        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2060        pub inputs: ::std::vec::Vec<JobBatchRequestInputsItem>,
2061    }
2062
2063    impl ::std::convert::From<&JobBatchRequest> for JobBatchRequest {
2064        fn from(value: &JobBatchRequest) -> Self {
2065            value.clone()
2066        }
2067    }
2068
2069    impl ::std::default::Default for JobBatchRequest {
2070        fn default() -> Self {
2071            Self {
2072                async_: Default::default(),
2073                concurrency: Default::default(),
2074                inputs: Default::default(),
2075            }
2076        }
2077    }
2078
2079    ///`JobBatchRequestInputsItem`
2080    ///
2081    /// <details><summary>JSON schema</summary>
2082    ///
2083    /// ```json
2084    ///{
2085    ///  "type": "object",
2086    ///  "required": [
2087    ///    "_path"
2088    ///  ],
2089    ///  "properties": {
2090    ///    "_path": {
2091    ///      "description": "rc/path",
2092    ///      "type": "string"
2093    ///    }
2094    ///  },
2095    ///  "additionalProperties": true
2096    ///}
2097    /// ```
2098    /// </details>
2099    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2100    pub struct JobBatchRequestInputsItem {
2101        ///rc/path
2102        #[serde(rename = "_path")]
2103        pub path: ::std::string::String,
2104    }
2105
2106    impl ::std::convert::From<&JobBatchRequestInputsItem> for JobBatchRequestInputsItem {
2107        fn from(value: &JobBatchRequestInputsItem) -> Self {
2108            value.clone()
2109        }
2110    }
2111
2112    ///`JobBatchResponse`
2113    ///
2114    /// <details><summary>JSON schema</summary>
2115    ///
2116    /// ```json
2117    ///{
2118    ///  "type": "object",
2119    ///  "required": [
2120    ///    "executeId",
2121    ///    "jobid"
2122    ///  ],
2123    ///  "properties": {
2124    ///    "executeId": {
2125    ///      "description": "Identifier for this rclone process.",
2126    ///      "type": "string"
2127    ///    },
2128    ///    "jobid": {
2129    ///      "description": "ID of the async job.",
2130    ///      "type": "integer"
2131    ///    }
2132    ///  }
2133    ///}
2134    /// ```
2135    /// </details>
2136    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2137    pub struct JobBatchResponse {
2138        ///Identifier for this rclone process.
2139        #[serde(rename = "executeId")]
2140        pub execute_id: ::std::string::String,
2141        ///ID of the async job.
2142        pub jobid: i64,
2143    }
2144
2145    impl ::std::convert::From<&JobBatchResponse> for JobBatchResponse {
2146        fn from(value: &JobBatchResponse) -> Self {
2147            value.clone()
2148        }
2149    }
2150
2151    ///`JobListResponse`
2152    ///
2153    /// <details><summary>JSON schema</summary>
2154    ///
2155    /// ```json
2156    ///{
2157    ///  "type": "object",
2158    ///  "required": [
2159    ///    "executeId",
2160    ///    "finishedIds",
2161    ///    "jobids",
2162    ///    "runningIds"
2163    ///  ],
2164    ///  "properties": {
2165    ///    "executeId": {
2166    ///      "description": "Identifier for this rclone process.",
2167    ///      "type": "string"
2168    ///    },
2169    ///    "finishedIds": {
2170    ///      "description": "Array of integer job ids that are finished.",
2171    ///      "type": "array",
2172    ///      "items": {
2173    ///        "type": "integer"
2174    ///      }
2175    ///    },
2176    ///    "jobids": {
2177    ///      "description": "Job IDs suitable for use with `job/status` and
2178    /// `job/stop`.",
2179    ///      "type": "array",
2180    ///      "items": {
2181    ///        "type": "number"
2182    ///      }
2183    ///    },
2184    ///    "runningIds": {
2185    ///      "description": "Array of integer job ids that are running.",
2186    ///      "type": "array",
2187    ///      "items": {
2188    ///        "type": "integer"
2189    ///      }
2190    ///    }
2191    ///  }
2192    ///}
2193    /// ```
2194    /// </details>
2195    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2196    pub struct JobListResponse {
2197        ///Identifier for this rclone process.
2198        #[serde(rename = "executeId")]
2199        pub execute_id: ::std::string::String,
2200        ///Array of integer job ids that are finished.
2201        #[serde(rename = "finishedIds")]
2202        pub finished_ids: ::std::vec::Vec<i64>,
2203        ///Job IDs suitable for use with `job/status` and `job/stop`.
2204        pub jobids: ::std::vec::Vec<f64>,
2205        ///Array of integer job ids that are running.
2206        #[serde(rename = "runningIds")]
2207        pub running_ids: ::std::vec::Vec<i64>,
2208    }
2209
2210    impl ::std::convert::From<&JobListResponse> for JobListResponse {
2211        fn from(value: &JobListResponse) -> Self {
2212            value.clone()
2213        }
2214    }
2215
2216    ///`JobStatusResponse`
2217    ///
2218    /// <details><summary>JSON schema</summary>
2219    ///
2220    /// ```json
2221    ///{
2222    ///  "type": "object",
2223    ///  "required": [
2224    ///    "duration",
2225    ///    "endTime",
2226    ///    "error",
2227    ///    "finished",
2228    ///    "id",
2229    ///    "startTime",
2230    ///    "success"
2231    ///  ],
2232    ///  "properties": {
2233    ///    "duration": {
2234    ///      "description": "Execution time in seconds.",
2235    ///      "type": "number"
2236    ///    },
2237    ///    "endTime": {
2238    ///      "description": "Timestamp when the job finished. (e.g.
2239    /// '2025-12-26T18:50:20.528746884+01:00')",
2240    ///      "type": "string"
2241    ///    },
2242    ///    "error": {
2243    ///      "description": "Error message, or empty string on success.",
2244    ///      "type": "string"
2245    ///    },
2246    ///    "finished": {
2247    ///      "description": "True once the job has completed.",
2248    ///      "type": "boolean"
2249    ///    },
2250    ///    "id": {
2251    ///      "description": "Job identifier.",
2252    ///      "type": "number"
2253    ///    },
2254    ///    "output": {
2255    ///      "description": "Synchronous-style output payload when available."
2256    ///    },
2257    ///    "progress": {
2258    ///      "description": "Progress measurements supplied by the underlying
2259    /// command."
2260    ///    },
2261    ///    "startTime": {
2262    ///      "description": "Timestamp when the job started. (e.g.
2263    /// '2025-12-24T18:50:20.5281314+01:00')",
2264    ///      "type": "string"
2265    ///    },
2266    ///    "success": {
2267    ///      "description": "True if the job completed successfully.",
2268    ///      "type": "boolean"
2269    ///    }
2270    ///  }
2271    ///}
2272    /// ```
2273    /// </details>
2274    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2275    pub struct JobStatusResponse {
2276        pub duration: f64,
2277        ///Timestamp when the job finished. (e.g.
2278        /// '2025-12-26T18:50:20.528746884+01:00')
2279        #[serde(rename = "endTime")]
2280        pub end_time: ::std::string::String,
2281        ///Error message, or empty string on success.
2282        pub error: ::std::string::String,
2283        ///True once the job has completed.
2284        pub finished: bool,
2285        pub id: f64,
2286        ///Synchronous-style output payload when available.
2287        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2288        pub output: ::std::option::Option<::serde_json::Value>,
2289        ///Progress measurements supplied by the underlying command.
2290        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2291        pub progress: ::std::option::Option<::serde_json::Value>,
2292        ///Timestamp when the job started. (e.g.
2293        /// '2025-12-24T18:50:20.5281314+01:00')
2294        #[serde(rename = "startTime")]
2295        pub start_time: ::std::string::String,
2296        ///True if the job completed successfully.
2297        pub success: bool,
2298    }
2299
2300    impl ::std::convert::From<&JobStatusResponse> for JobStatusResponse {
2301        fn from(value: &JobStatusResponse) -> Self {
2302            value.clone()
2303        }
2304    }
2305
2306    ///`MountListmountsResponse`
2307    ///
2308    /// <details><summary>JSON schema</summary>
2309    ///
2310    /// ```json
2311    ///{
2312    ///  "type": "object",
2313    ///  "required": [
2314    ///    "mountPoints"
2315    ///  ],
2316    ///  "properties": {
2317    ///    "mountPoints": {
2318    ///      "type": "array",
2319    ///      "items": {
2320    ///        "type": "object",
2321    ///        "required": [
2322    ///          "Fs",
2323    ///          "MountPoint",
2324    ///          "MountedOn"
2325    ///        ],
2326    ///        "properties": {
2327    ///          "Fs": {
2328    ///            "type": "string"
2329    ///          },
2330    ///          "MountPoint": {
2331    ///            "type": "string"
2332    ///          },
2333    ///          "MountedOn": {
2334    ///            "type": "string",
2335    ///            "format": "date-time"
2336    ///          }
2337    ///        },
2338    ///        "additionalProperties": false
2339    ///      }
2340    ///    }
2341    ///  }
2342    ///}
2343    /// ```
2344    /// </details>
2345    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2346    pub struct MountListmountsResponse {
2347        #[serde(rename = "mountPoints")]
2348        pub mount_points: ::std::vec::Vec<MountListmountsResponseMountPointsItem>,
2349    }
2350
2351    impl ::std::convert::From<&MountListmountsResponse> for MountListmountsResponse {
2352        fn from(value: &MountListmountsResponse) -> Self {
2353            value.clone()
2354        }
2355    }
2356
2357    ///`MountListmountsResponseMountPointsItem`
2358    ///
2359    /// <details><summary>JSON schema</summary>
2360    ///
2361    /// ```json
2362    ///{
2363    ///  "type": "object",
2364    ///  "required": [
2365    ///    "Fs",
2366    ///    "MountPoint",
2367    ///    "MountedOn"
2368    ///  ],
2369    ///  "properties": {
2370    ///    "Fs": {
2371    ///      "type": "string"
2372    ///    },
2373    ///    "MountPoint": {
2374    ///      "type": "string"
2375    ///    },
2376    ///    "MountedOn": {
2377    ///      "type": "string",
2378    ///      "format": "date-time"
2379    ///    }
2380    ///  },
2381    ///  "additionalProperties": false
2382    ///}
2383    /// ```
2384    /// </details>
2385    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2386    #[serde(deny_unknown_fields)]
2387    pub struct MountListmountsResponseMountPointsItem {
2388        #[serde(rename = "Fs")]
2389        pub fs: ::std::string::String,
2390        #[serde(rename = "MountPoint")]
2391        pub mount_point: ::std::string::String,
2392        #[serde(rename = "MountedOn")]
2393        pub mounted_on: ::chrono::DateTime<::chrono::offset::Utc>,
2394    }
2395
2396    impl ::std::convert::From<&MountListmountsResponseMountPointsItem>
2397        for MountListmountsResponseMountPointsItem
2398    {
2399        fn from(value: &MountListmountsResponseMountPointsItem) -> Self {
2400            value.clone()
2401        }
2402    }
2403
2404    ///`MountTypesResponse`
2405    ///
2406    /// <details><summary>JSON schema</summary>
2407    ///
2408    /// ```json
2409    ///{
2410    ///  "type": "object",
2411    ///  "required": [
2412    ///    "mountTypes"
2413    ///  ],
2414    ///  "properties": {
2415    ///    "mountTypes": {
2416    ///      "type": "array",
2417    ///      "items": {
2418    ///        "type": "string"
2419    ///      }
2420    ///    }
2421    ///  }
2422    ///}
2423    /// ```
2424    /// </details>
2425    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2426    pub struct MountTypesResponse {
2427        #[serde(rename = "mountTypes")]
2428        pub mount_types: ::std::vec::Vec<::std::string::String>,
2429    }
2430
2431    impl ::std::convert::From<&MountTypesResponse> for MountTypesResponse {
2432        fn from(value: &MountTypesResponse) -> Self {
2433            value.clone()
2434        }
2435    }
2436
2437    ///`OperationsAboutResponse`
2438    ///
2439    /// <details><summary>JSON schema</summary>
2440    ///
2441    /// ```json
2442    ///{
2443    ///  "type": "object",
2444    ///  "required": [
2445    ///    "free",
2446    ///    "total",
2447    ///    "used"
2448    ///  ],
2449    ///  "properties": {
2450    ///    "free": {
2451    ///      "type": "number"
2452    ///    },
2453    ///    "objects": {
2454    ///      "type": "number"
2455    ///    },
2456    ///    "other": {
2457    ///      "type": "number"
2458    ///    },
2459    ///    "total": {
2460    ///      "type": "number"
2461    ///    },
2462    ///    "trashed": {
2463    ///      "type": "number"
2464    ///    },
2465    ///    "used": {
2466    ///      "type": "number"
2467    ///    }
2468    ///  }
2469    ///}
2470    /// ```
2471    /// </details>
2472    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2473    pub struct OperationsAboutResponse {
2474        pub free: f64,
2475        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2476        pub objects: ::std::option::Option<f64>,
2477        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2478        pub other: ::std::option::Option<f64>,
2479        pub total: f64,
2480        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2481        pub trashed: ::std::option::Option<f64>,
2482        pub used: f64,
2483    }
2484
2485    impl ::std::convert::From<&OperationsAboutResponse> for OperationsAboutResponse {
2486        fn from(value: &OperationsAboutResponse) -> Self {
2487            value.clone()
2488        }
2489    }
2490
2491    ///`OperationsCheckResponse`
2492    ///
2493    /// <details><summary>JSON schema</summary>
2494    ///
2495    /// ```json
2496    ///{
2497    ///  "type": "object",
2498    ///  "required": [
2499    ///    "status",
2500    ///    "success"
2501    ///  ],
2502    ///  "properties": {
2503    ///    "combined": {
2504    ///      "description": "Combined summary lines when `combined=true` is
2505    /// requested.",
2506    ///      "type": "array",
2507    ///      "items": {
2508    ///        "type": "string"
2509    ///      }
2510    ///    },
2511    ///    "differ": {
2512    ///      "description": "Files that differed between source and
2513    /// destination.",
2514    ///      "type": "array",
2515    ///      "items": {
2516    ///        "type": "string"
2517    ///      }
2518    ///    },
2519    ///    "error": {
2520    ///      "description": "Entries that produced errors during the check.",
2521    ///      "type": "array",
2522    ///      "items": {
2523    ///        "type": "string"
2524    ///      }
2525    ///    },
2526    ///    "hashType": {
2527    ///      "description": "Hash algorithm used for comparisons when
2528    /// applicable.",
2529    ///      "type": "string"
2530    ///    },
2531    ///    "match": {
2532    ///      "description": "Files that matched on both sides.",
2533    ///      "type": "array",
2534    ///      "items": {
2535    ///        "type": "string"
2536    ///      }
2537    ///    },
2538    ///    "missingOnDst": {
2539    ///      "description": "Files present on the source but missing from the
2540    /// destination.",
2541    ///      "type": "array",
2542    ///      "items": {
2543    ///        "type": "string"
2544    ///      }
2545    ///    },
2546    ///    "missingOnSrc": {
2547    ///      "description": "Files present on the destination but missing from
2548    /// the source.",
2549    ///      "type": "array",
2550    ///      "items": {
2551    ///        "type": "string"
2552    ///      }
2553    ///    },
2554    ///    "status": {
2555    ///      "description": "Human readable status string.",
2556    ///      "type": "string"
2557    ///    },
2558    ///    "success": {
2559    ///      "description": "True when the check completes without differences
2560    /// or errors.",
2561    ///      "type": "boolean"
2562    ///    }
2563    ///  }
2564    ///}
2565    /// ```
2566    /// </details>
2567    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2568    pub struct OperationsCheckResponse {
2569        ///Combined summary lines when `combined=true` is requested.
2570        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2571        pub combined: ::std::vec::Vec<::std::string::String>,
2572        ///Files that differed between source and destination.
2573        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2574        pub differ: ::std::vec::Vec<::std::string::String>,
2575        ///Entries that produced errors during the check.
2576        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2577        pub error: ::std::vec::Vec<::std::string::String>,
2578        ///Hash algorithm used for comparisons when applicable.
2579        #[serde(
2580            rename = "hashType",
2581            default,
2582            skip_serializing_if = "::std::option::Option::is_none"
2583        )]
2584        pub hash_type: ::std::option::Option<::std::string::String>,
2585        ///Files that matched on both sides.
2586        #[serde(
2587            rename = "match",
2588            default,
2589            skip_serializing_if = "::std::vec::Vec::is_empty"
2590        )]
2591        pub match_: ::std::vec::Vec<::std::string::String>,
2592        ///Files present on the source but missing from the destination.
2593        #[serde(
2594            rename = "missingOnDst",
2595            default,
2596            skip_serializing_if = "::std::vec::Vec::is_empty"
2597        )]
2598        pub missing_on_dst: ::std::vec::Vec<::std::string::String>,
2599        ///Files present on the destination but missing from the source.
2600        #[serde(
2601            rename = "missingOnSrc",
2602            default,
2603            skip_serializing_if = "::std::vec::Vec::is_empty"
2604        )]
2605        pub missing_on_src: ::std::vec::Vec<::std::string::String>,
2606        ///Human readable status string.
2607        pub status: ::std::string::String,
2608        ///True when the check completes without differences or errors.
2609        pub success: bool,
2610    }
2611
2612    impl ::std::convert::From<&OperationsCheckResponse> for OperationsCheckResponse {
2613        fn from(value: &OperationsCheckResponse) -> Self {
2614            value.clone()
2615        }
2616    }
2617
2618    ///`OperationsFsinfoResponse`
2619    ///
2620    /// <details><summary>JSON schema</summary>
2621    ///
2622    /// ```json
2623    ///{
2624    ///  "type": "object",
2625    ///  "required": [
2626    ///    "Features",
2627    ///    "Hashes",
2628    ///    "Name",
2629    ///    "Precision",
2630    ///    "Root",
2631    ///    "String"
2632    ///  ],
2633    ///  "properties": {
2634    ///    "Features": {
2635    ///      "type": "object",
2636    ///      "additionalProperties": {
2637    ///        "type": "boolean"
2638    ///      }
2639    ///    },
2640    ///    "Hashes": {
2641    ///      "type": "array",
2642    ///      "items": {
2643    ///        "type": "string"
2644    ///      }
2645    ///    },
2646    ///    "MetadataInfo": {
2647    ///      "type": [
2648    ///        "object",
2649    ///        "null"
2650    ///      ],
2651    ///      "additionalProperties": true
2652    ///    },
2653    ///    "Name": {
2654    ///      "type": "string"
2655    ///    },
2656    ///    "Precision": {
2657    ///      "type": "number"
2658    ///    },
2659    ///    "Root": {
2660    ///      "type": "string"
2661    ///    },
2662    ///    "String": {
2663    ///      "type": "string"
2664    ///    }
2665    ///  }
2666    ///}
2667    /// ```
2668    /// </details>
2669    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2670    pub struct OperationsFsinfoResponse {
2671        #[serde(rename = "Features")]
2672        pub features: ::std::collections::HashMap<::std::string::String, bool>,
2673        #[serde(rename = "Hashes")]
2674        pub hashes: ::std::vec::Vec<::std::string::String>,
2675        #[serde(
2676            rename = "MetadataInfo",
2677            default,
2678            skip_serializing_if = "::std::option::Option::is_none"
2679        )]
2680        pub metadata_info:
2681            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
2682        #[serde(rename = "Name")]
2683        pub name: ::std::string::String,
2684        #[serde(rename = "Precision")]
2685        pub precision: f64,
2686        #[serde(rename = "Root")]
2687        pub root: ::std::string::String,
2688        #[serde(rename = "String")]
2689        pub string: ::std::string::String,
2690    }
2691
2692    impl ::std::convert::From<&OperationsFsinfoResponse> for OperationsFsinfoResponse {
2693        fn from(value: &OperationsFsinfoResponse) -> Self {
2694            value.clone()
2695        }
2696    }
2697
2698    ///`OperationsHashsumResponse`
2699    ///
2700    /// <details><summary>JSON schema</summary>
2701    ///
2702    /// ```json
2703    ///{
2704    ///  "type": "object",
2705    ///  "required": [
2706    ///    "hashType",
2707    ///    "hashsum"
2708    ///  ],
2709    ///  "properties": {
2710    ///    "hashType": {
2711    ///      "type": "string"
2712    ///    },
2713    ///    "hashsum": {
2714    ///      "type": "array",
2715    ///      "items": {
2716    ///        "type": "string"
2717    ///      }
2718    ///    }
2719    ///  }
2720    ///}
2721    /// ```
2722    /// </details>
2723    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2724    pub struct OperationsHashsumResponse {
2725        #[serde(rename = "hashType")]
2726        pub hash_type: ::std::string::String,
2727        pub hashsum: ::std::vec::Vec<::std::string::String>,
2728    }
2729
2730    impl ::std::convert::From<&OperationsHashsumResponse> for OperationsHashsumResponse {
2731        fn from(value: &OperationsHashsumResponse) -> Self {
2732            value.clone()
2733        }
2734    }
2735
2736    ///`OperationsListResponse`
2737    ///
2738    /// <details><summary>JSON schema</summary>
2739    ///
2740    /// ```json
2741    ///{
2742    ///  "type": "object",
2743    ///  "required": [
2744    ///    "list"
2745    ///  ],
2746    ///  "properties": {
2747    ///    "list": {
2748    ///      "description": "Array of entries equivalent to the items returned
2749    /// by `rclone lsjson`.",
2750    ///      "type": "array",
2751    ///      "items": {
2752    ///        "type": "object",
2753    ///        "required": [
2754    ///          "IsDir",
2755    ///          "Name",
2756    ///          "Path"
2757    ///        ],
2758    ///        "properties": {
2759    ///          "Encrypted": {
2760    ///            "description": "Encrypted entry name when using crypt
2761    /// remotes.",
2762    ///            "type": "string"
2763    ///          },
2764    ///          "EncryptedPath": {
2765    ///            "description": "Encrypted path when using crypt remotes.",
2766    ///            "type": "string"
2767    ///          },
2768    ///          "Hashes": {
2769    ///            "description": "Hash digests keyed by algorithm when
2770    /// requested.",
2771    ///            "type": "object",
2772    ///            "additionalProperties": {
2773    ///              "type": "string"
2774    ///            }
2775    ///          },
2776    ///          "ID": {
2777    ///            "description": "Backend-specific identifier when provided.",
2778    ///            "type": "string"
2779    ///          },
2780    ///          "IsBucket": {
2781    ///            "description": "True for bucket/root entries on bucket-based
2782    /// remotes.",
2783    ///            "type": "boolean"
2784    ///          },
2785    ///          "IsDir": {
2786    ///            "description": "True if the entry represents a directory.",
2787    ///            "type": "boolean"
2788    ///          },
2789    ///          "Metadata": {
2790    ///            "description": "Backend-provided metadata map.",
2791    ///            "type": "object",
2792    ///            "additionalProperties": {}
2793    ///          },
2794    ///          "MimeType": {
2795    ///            "description": "MIME type where available.",
2796    ///            "type": "string"
2797    ///          },
2798    ///          "ModTime": {
2799    ///            "description": "Modification timestamp in RFC3339 format.",
2800    ///            "type": "string"
2801    ///          },
2802    ///          "Name": {
2803    ///            "description": "Base name of the entry.",
2804    ///            "type": "string"
2805    ///          },
2806    ///          "OrigID": {
2807    ///            "description": "Original backend identifier when recorded.",
2808    ///            "type": "string"
2809    ///          },
2810    ///          "Path": {
2811    ///            "description": "Path relative to the requested remote root.",
2812    ///            "type": "string"
2813    ///          },
2814    ///          "Size": {
2815    ///            "description": "Object size in bytes.",
2816    ///            "type": "number"
2817    ///          },
2818    ///          "Tier": {
2819    ///            "description": "Storage class or tier, if supplied by the
2820    /// backend.",
2821    ///            "type": "string"
2822    ///          }
2823    ///        }
2824    ///      }
2825    ///    }
2826    ///  }
2827    ///}
2828    /// ```
2829    /// </details>
2830    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2831    pub struct OperationsListResponse {
2832        ///Array of entries equivalent to the items returned by `rclone
2833        /// lsjson`.
2834        pub list: ::std::vec::Vec<OperationsListResponseListItem>,
2835    }
2836
2837    impl ::std::convert::From<&OperationsListResponse> for OperationsListResponse {
2838        fn from(value: &OperationsListResponse) -> Self {
2839            value.clone()
2840        }
2841    }
2842
2843    ///`OperationsListResponseListItem`
2844    ///
2845    /// <details><summary>JSON schema</summary>
2846    ///
2847    /// ```json
2848    ///{
2849    ///  "type": "object",
2850    ///  "required": [
2851    ///    "IsDir",
2852    ///    "Name",
2853    ///    "Path"
2854    ///  ],
2855    ///  "properties": {
2856    ///    "Encrypted": {
2857    ///      "description": "Encrypted entry name when using crypt remotes.",
2858    ///      "type": "string"
2859    ///    },
2860    ///    "EncryptedPath": {
2861    ///      "description": "Encrypted path when using crypt remotes.",
2862    ///      "type": "string"
2863    ///    },
2864    ///    "Hashes": {
2865    ///      "description": "Hash digests keyed by algorithm when requested.",
2866    ///      "type": "object",
2867    ///      "additionalProperties": {
2868    ///        "type": "string"
2869    ///      }
2870    ///    },
2871    ///    "ID": {
2872    ///      "description": "Backend-specific identifier when provided.",
2873    ///      "type": "string"
2874    ///    },
2875    ///    "IsBucket": {
2876    ///      "description": "True for bucket/root entries on bucket-based
2877    /// remotes.",
2878    ///      "type": "boolean"
2879    ///    },
2880    ///    "IsDir": {
2881    ///      "description": "True if the entry represents a directory.",
2882    ///      "type": "boolean"
2883    ///    },
2884    ///    "Metadata": {
2885    ///      "description": "Backend-provided metadata map.",
2886    ///      "type": "object",
2887    ///      "additionalProperties": {}
2888    ///    },
2889    ///    "MimeType": {
2890    ///      "description": "MIME type where available.",
2891    ///      "type": "string"
2892    ///    },
2893    ///    "ModTime": {
2894    ///      "description": "Modification timestamp in RFC3339 format.",
2895    ///      "type": "string"
2896    ///    },
2897    ///    "Name": {
2898    ///      "description": "Base name of the entry.",
2899    ///      "type": "string"
2900    ///    },
2901    ///    "OrigID": {
2902    ///      "description": "Original backend identifier when recorded.",
2903    ///      "type": "string"
2904    ///    },
2905    ///    "Path": {
2906    ///      "description": "Path relative to the requested remote root.",
2907    ///      "type": "string"
2908    ///    },
2909    ///    "Size": {
2910    ///      "description": "Object size in bytes.",
2911    ///      "type": "number"
2912    ///    },
2913    ///    "Tier": {
2914    ///      "description": "Storage class or tier, if supplied by the
2915    /// backend.",
2916    ///      "type": "string"
2917    ///    }
2918    ///  }
2919    ///}
2920    /// ```
2921    /// </details>
2922    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2923    pub struct OperationsListResponseListItem {
2924        ///Encrypted entry name when using crypt remotes.
2925        #[serde(
2926            rename = "Encrypted",
2927            default,
2928            skip_serializing_if = "::std::option::Option::is_none"
2929        )]
2930        pub encrypted: ::std::option::Option<::std::string::String>,
2931        ///Encrypted path when using crypt remotes.
2932        #[serde(
2933            rename = "EncryptedPath",
2934            default,
2935            skip_serializing_if = "::std::option::Option::is_none"
2936        )]
2937        pub encrypted_path: ::std::option::Option<::std::string::String>,
2938        ///Hash digests keyed by algorithm when requested.
2939        #[serde(
2940            rename = "Hashes",
2941            default,
2942            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
2943        )]
2944        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
2945        ///Backend-specific identifier when provided.
2946        #[serde(
2947            rename = "ID",
2948            default,
2949            skip_serializing_if = "::std::option::Option::is_none"
2950        )]
2951        pub id: ::std::option::Option<::std::string::String>,
2952        ///True for bucket/root entries on bucket-based remotes.
2953        #[serde(
2954            rename = "IsBucket",
2955            default,
2956            skip_serializing_if = "::std::option::Option::is_none"
2957        )]
2958        pub is_bucket: ::std::option::Option<bool>,
2959        ///True if the entry represents a directory.
2960        #[serde(rename = "IsDir")]
2961        pub is_dir: bool,
2962        ///Backend-provided metadata map.
2963        #[serde(
2964            rename = "Metadata",
2965            default,
2966            skip_serializing_if = "::serde_json::Map::is_empty"
2967        )]
2968        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
2969        ///MIME type where available.
2970        #[serde(
2971            rename = "MimeType",
2972            default,
2973            skip_serializing_if = "::std::option::Option::is_none"
2974        )]
2975        pub mime_type: ::std::option::Option<::std::string::String>,
2976        ///Modification timestamp in RFC3339 format.
2977        #[serde(
2978            rename = "ModTime",
2979            default,
2980            skip_serializing_if = "::std::option::Option::is_none"
2981        )]
2982        pub mod_time: ::std::option::Option<::std::string::String>,
2983        ///Base name of the entry.
2984        #[serde(rename = "Name")]
2985        pub name: ::std::string::String,
2986        ///Original backend identifier when recorded.
2987        #[serde(
2988            rename = "OrigID",
2989            default,
2990            skip_serializing_if = "::std::option::Option::is_none"
2991        )]
2992        pub orig_id: ::std::option::Option<::std::string::String>,
2993        ///Path relative to the requested remote root.
2994        #[serde(rename = "Path")]
2995        pub path: ::std::string::String,
2996        #[serde(
2997            rename = "Size",
2998            default,
2999            skip_serializing_if = "::std::option::Option::is_none"
3000        )]
3001        pub size: ::std::option::Option<f64>,
3002        ///Storage class or tier, if supplied by the backend.
3003        #[serde(
3004            rename = "Tier",
3005            default,
3006            skip_serializing_if = "::std::option::Option::is_none"
3007        )]
3008        pub tier: ::std::option::Option<::std::string::String>,
3009    }
3010
3011    impl ::std::convert::From<&OperationsListResponseListItem> for OperationsListResponseListItem {
3012        fn from(value: &OperationsListResponseListItem) -> Self {
3013            value.clone()
3014        }
3015    }
3016
3017    ///`OperationsPubliclinkResponse`
3018    ///
3019    /// <details><summary>JSON schema</summary>
3020    ///
3021    /// ```json
3022    ///{
3023    ///  "type": "object",
3024    ///  "required": [
3025    ///    "url"
3026    ///  ],
3027    ///  "properties": {
3028    ///    "url": {
3029    ///      "type": "string",
3030    ///      "format": "uri"
3031    ///    }
3032    ///  }
3033    ///}
3034    /// ```
3035    /// </details>
3036    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3037    pub struct OperationsPubliclinkResponse {
3038        pub url: ::std::string::String,
3039    }
3040
3041    impl ::std::convert::From<&OperationsPubliclinkResponse> for OperationsPubliclinkResponse {
3042        fn from(value: &OperationsPubliclinkResponse) -> Self {
3043            value.clone()
3044        }
3045    }
3046
3047    ///`OperationsSizeResponse`
3048    ///
3049    /// <details><summary>JSON schema</summary>
3050    ///
3051    /// ```json
3052    ///{
3053    ///  "type": "object",
3054    ///  "required": [
3055    ///    "bytes",
3056    ///    "count",
3057    ///    "sizeless"
3058    ///  ],
3059    ///  "properties": {
3060    ///    "bytes": {
3061    ///      "type": "number"
3062    ///    },
3063    ///    "count": {
3064    ///      "type": "integer"
3065    ///    },
3066    ///    "sizeless": {
3067    ///      "type": "integer"
3068    ///    }
3069    ///  }
3070    ///}
3071    /// ```
3072    /// </details>
3073    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3074    pub struct OperationsSizeResponse {
3075        pub bytes: f64,
3076        pub count: i64,
3077        pub sizeless: i64,
3078    }
3079
3080    impl ::std::convert::From<&OperationsSizeResponse> for OperationsSizeResponse {
3081        fn from(value: &OperationsSizeResponse) -> Self {
3082            value.clone()
3083        }
3084    }
3085
3086    ///`OperationsStatResponse`
3087    ///
3088    /// <details><summary>JSON schema</summary>
3089    ///
3090    /// ```json
3091    ///{
3092    ///  "type": "object",
3093    ///  "required": [
3094    ///    "IsDir",
3095    ///    "MimeType",
3096    ///    "ModTime",
3097    ///    "Name",
3098    ///    "Path",
3099    ///    "Size"
3100    ///  ],
3101    ///  "properties": {
3102    ///    "Encrypted": {
3103    ///      "description": "Encrypted entry name when using crypt remotes.",
3104    ///      "type": "string"
3105    ///    },
3106    ///    "EncryptedPath": {
3107    ///      "description": "Encrypted path when using crypt remotes.",
3108    ///      "type": "string"
3109    ///    },
3110    ///    "Hashes": {
3111    ///      "description": "Hash digests keyed by algorithm when requested.",
3112    ///      "type": "object",
3113    ///      "additionalProperties": {
3114    ///        "type": "string"
3115    ///      }
3116    ///    },
3117    ///    "ID": {
3118    ///      "description": "Backend-specific identifier when provided.",
3119    ///      "type": "string"
3120    ///    },
3121    ///    "IsBucket": {
3122    ///      "description": "True for bucket/root entries on bucket-based
3123    /// remotes.",
3124    ///      "type": "boolean"
3125    ///    },
3126    ///    "IsDir": {
3127    ///      "description": "True if the entry is a directory.",
3128    ///      "type": "boolean"
3129    ///    },
3130    ///    "Metadata": {
3131    ///      "description": "Backend-provided metadata map.",
3132    ///      "type": "object",
3133    ///      "additionalProperties": {}
3134    ///    },
3135    ///    "MimeType": {
3136    ///      "description": "MIME type where available.",
3137    ///      "type": "string"
3138    ///    },
3139    ///    "ModTime": {
3140    ///      "description": "Modification timestamp in RFC3339 format.",
3141    ///      "type": "string"
3142    ///    },
3143    ///    "Name": {
3144    ///      "description": "Base name of the entry.",
3145    ///      "type": "string"
3146    ///    },
3147    ///    "OrigID": {
3148    ///      "description": "Original backend identifier when recorded.",
3149    ///      "type": "string"
3150    ///    },
3151    ///    "Path": {
3152    ///      "description": "Path relative to the remote root.",
3153    ///      "type": "string"
3154    ///    },
3155    ///    "Size": {
3156    ///      "description": "Object size in bytes.",
3157    ///      "type": "number"
3158    ///    },
3159    ///    "Tier": {
3160    ///      "description": "Storage class or tier, if supplied by the
3161    /// backend.",
3162    ///      "type": "string"
3163    ///    }
3164    ///  }
3165    ///}
3166    /// ```
3167    /// </details>
3168    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3169    pub struct OperationsStatResponse {
3170        ///Encrypted entry name when using crypt remotes.
3171        #[serde(
3172            rename = "Encrypted",
3173            default,
3174            skip_serializing_if = "::std::option::Option::is_none"
3175        )]
3176        pub encrypted: ::std::option::Option<::std::string::String>,
3177        ///Encrypted path when using crypt remotes.
3178        #[serde(
3179            rename = "EncryptedPath",
3180            default,
3181            skip_serializing_if = "::std::option::Option::is_none"
3182        )]
3183        pub encrypted_path: ::std::option::Option<::std::string::String>,
3184        ///Hash digests keyed by algorithm when requested.
3185        #[serde(
3186            rename = "Hashes",
3187            default,
3188            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
3189        )]
3190        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3191        ///Backend-specific identifier when provided.
3192        #[serde(
3193            rename = "ID",
3194            default,
3195            skip_serializing_if = "::std::option::Option::is_none"
3196        )]
3197        pub id: ::std::option::Option<::std::string::String>,
3198        ///True for bucket/root entries on bucket-based remotes.
3199        #[serde(
3200            rename = "IsBucket",
3201            default,
3202            skip_serializing_if = "::std::option::Option::is_none"
3203        )]
3204        pub is_bucket: ::std::option::Option<bool>,
3205        ///True if the entry is a directory.
3206        #[serde(rename = "IsDir")]
3207        pub is_dir: bool,
3208        ///Backend-provided metadata map.
3209        #[serde(
3210            rename = "Metadata",
3211            default,
3212            skip_serializing_if = "::serde_json::Map::is_empty"
3213        )]
3214        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3215        ///MIME type where available.
3216        #[serde(rename = "MimeType")]
3217        pub mime_type: ::std::string::String,
3218        ///Modification timestamp in RFC3339 format.
3219        #[serde(rename = "ModTime")]
3220        pub mod_time: ::std::string::String,
3221        ///Base name of the entry.
3222        #[serde(rename = "Name")]
3223        pub name: ::std::string::String,
3224        ///Original backend identifier when recorded.
3225        #[serde(
3226            rename = "OrigID",
3227            default,
3228            skip_serializing_if = "::std::option::Option::is_none"
3229        )]
3230        pub orig_id: ::std::option::Option<::std::string::String>,
3231        ///Path relative to the remote root.
3232        #[serde(rename = "Path")]
3233        pub path: ::std::string::String,
3234        #[serde(rename = "Size")]
3235        pub size: f64,
3236        ///Storage class or tier, if supplied by the backend.
3237        #[serde(
3238            rename = "Tier",
3239            default,
3240            skip_serializing_if = "::std::option::Option::is_none"
3241        )]
3242        pub tier: ::std::option::Option<::std::string::String>,
3243    }
3244
3245    impl ::std::convert::From<&OperationsStatResponse> for OperationsStatResponse {
3246        fn from(value: &OperationsStatResponse) -> Self {
3247            value.clone()
3248        }
3249    }
3250
3251    ///`OptionsBlocksResponse`
3252    ///
3253    /// <details><summary>JSON schema</summary>
3254    ///
3255    /// ```json
3256    ///{
3257    ///  "type": "object",
3258    ///  "required": [
3259    ///    "options"
3260    ///  ],
3261    ///  "properties": {
3262    ///    "options": {
3263    ///      "type": "array",
3264    ///      "items": {
3265    ///        "type": "string"
3266    ///      }
3267    ///    }
3268    ///  }
3269    ///}
3270    /// ```
3271    /// </details>
3272    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3273    pub struct OptionsBlocksResponse {
3274        pub options: ::std::vec::Vec<::std::string::String>,
3275    }
3276
3277    impl ::std::convert::From<&OptionsBlocksResponse> for OptionsBlocksResponse {
3278        fn from(value: &OptionsBlocksResponse) -> Self {
3279            value.clone()
3280        }
3281    }
3282
3283    ///`OptionsGetResponse`
3284    ///
3285    /// <details><summary>JSON schema</summary>
3286    ///
3287    /// ```json
3288    ///{
3289    ///  "type": "object",
3290    ///  "required": [
3291    ///    "dlna",
3292    ///    "filter",
3293    ///    "ftp",
3294    ///    "http",
3295    ///    "log",
3296    ///    "main",
3297    ///    "mount",
3298    ///    "nfs",
3299    ///    "proxy",
3300    ///    "rc",
3301    ///    "restic",
3302    ///    "s3",
3303    ///    "sftp",
3304    ///    "vfs",
3305    ///    "webdav"
3306    ///  ],
3307    ///  "properties": {
3308    ///    "dlna": {
3309    ///      "type": "object",
3310    ///      "additionalProperties": true
3311    ///    },
3312    ///    "filter": {
3313    ///      "type": "object",
3314    ///      "additionalProperties": true
3315    ///    },
3316    ///    "ftp": {
3317    ///      "type": "object",
3318    ///      "additionalProperties": true
3319    ///    },
3320    ///    "http": {
3321    ///      "type": "object",
3322    ///      "additionalProperties": true
3323    ///    },
3324    ///    "log": {
3325    ///      "type": "object",
3326    ///      "additionalProperties": true
3327    ///    },
3328    ///    "main": {
3329    ///      "type": "object",
3330    ///      "additionalProperties": true
3331    ///    },
3332    ///    "mount": {
3333    ///      "type": "object",
3334    ///      "additionalProperties": true
3335    ///    },
3336    ///    "nfs": {
3337    ///      "type": "object",
3338    ///      "additionalProperties": true
3339    ///    },
3340    ///    "proxy": {
3341    ///      "type": "object",
3342    ///      "additionalProperties": true
3343    ///    },
3344    ///    "rc": {
3345    ///      "type": "object",
3346    ///      "additionalProperties": true
3347    ///    },
3348    ///    "restic": {
3349    ///      "type": "object",
3350    ///      "additionalProperties": true
3351    ///    },
3352    ///    "s3": {
3353    ///      "type": "object",
3354    ///      "additionalProperties": true
3355    ///    },
3356    ///    "sftp": {
3357    ///      "type": "object",
3358    ///      "additionalProperties": true
3359    ///    },
3360    ///    "vfs": {
3361    ///      "type": "object",
3362    ///      "additionalProperties": true
3363    ///    },
3364    ///    "webdav": {
3365    ///      "type": "object",
3366    ///      "additionalProperties": true
3367    ///    }
3368    ///  },
3369    ///  "additionalProperties": true
3370    ///}
3371    /// ```
3372    /// </details>
3373    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3374    pub struct OptionsGetResponse {
3375        pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3376        pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3377        pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3378        pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3379        pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3380        pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3381        pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3382        pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3383        pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3384        pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3385        pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3386        pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3387        pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3388        pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3389        pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3390    }
3391
3392    impl ::std::convert::From<&OptionsGetResponse> for OptionsGetResponse {
3393        fn from(value: &OptionsGetResponse) -> Self {
3394            value.clone()
3395        }
3396    }
3397
3398    ///`OptionsInfoOption`
3399    ///
3400    /// <details><summary>JSON schema</summary>
3401    ///
3402    /// ```json
3403    ///{
3404    ///  "type": "object",
3405    ///  "required": [
3406    ///    "Advanced",
3407    ///    "Default",
3408    ///    "DefaultStr",
3409    ///    "Exclusive",
3410    ///    "FieldName",
3411    ///    "Help",
3412    ///    "Hide",
3413    ///    "IsPassword",
3414    ///    "Name",
3415    ///    "NoPrefix",
3416    ///    "Required",
3417    ///    "Sensitive",
3418    ///    "Type",
3419    ///    "Value",
3420    ///    "ValueStr"
3421    ///  ],
3422    ///  "properties": {
3423    ///    "Advanced": {
3424    ///      "type": "boolean"
3425    ///    },
3426    ///    "Default": {
3427    ///      "description": "Default value for this option.",
3428    ///      "anyOf": [
3429    ///        {
3430    ///          "type": "array",
3431    ///          "items": {
3432    ///            "type": "string"
3433    ///          }
3434    ///        },
3435    ///        {
3436    ///          "type": "boolean"
3437    ///        },
3438    ///        {
3439    ///          "type": "number"
3440    ///        },
3441    ///        {
3442    ///          "type": "string"
3443    ///        },
3444    ///        {
3445    ///          "type": "object",
3446    ///          "required": [
3447    ///            "Valid",
3448    ///            "Value"
3449    ///          ],
3450    ///          "properties": {
3451    ///            "Valid": {
3452    ///              "type": "boolean"
3453    ///            },
3454    ///            "Value": {
3455    ///              "type": "boolean"
3456    ///            }
3457    ///          },
3458    ///          "additionalProperties": false
3459    ///        }
3460    ///      ]
3461    ///    },
3462    ///    "DefaultStr": {
3463    ///      "type": "string"
3464    ///    },
3465    ///    "Examples": {
3466    ///      "type": "array",
3467    ///      "items": {
3468    ///        "$ref": "#/components/schemas/OptionsInfoOptionExample"
3469    ///      }
3470    ///    },
3471    ///    "Exclusive": {
3472    ///      "type": "boolean"
3473    ///    },
3474    ///    "FieldName": {
3475    ///      "type": "string"
3476    ///    },
3477    ///    "Groups": {
3478    ///      "type": "string"
3479    ///    },
3480    ///    "Help": {
3481    ///      "type": "string"
3482    ///    },
3483    ///    "Hide": {
3484    ///      "type": "integer"
3485    ///    },
3486    ///    "IsPassword": {
3487    ///      "type": "boolean"
3488    ///    },
3489    ///    "Name": {
3490    ///      "type": "string"
3491    ///    },
3492    ///    "NoPrefix": {
3493    ///      "type": "boolean"
3494    ///    },
3495    ///    "Required": {
3496    ///      "type": "boolean"
3497    ///    },
3498    ///    "Sensitive": {
3499    ///      "type": "boolean"
3500    ///    },
3501    ///    "ShortOpt": {
3502    ///      "type": "string"
3503    ///    },
3504    ///    "Type": {
3505    ///      "type": "string"
3506    ///    },
3507    ///    "Value": {
3508    ///      "oneOf": [
3509    ///        {
3510    ///          "type": "null"
3511    ///        },
3512    ///        {
3513    ///          "anyOf": [
3514    ///            {
3515    ///              "type": "boolean"
3516    ///            },
3517    ///            {
3518    ///              "type": "number"
3519    ///            }
3520    ///          ]
3521    ///        }
3522    ///      ]
3523    ///    },
3524    ///    "ValueStr": {
3525    ///      "type": "string"
3526    ///    }
3527    ///  },
3528    ///  "additionalProperties": true
3529    ///}
3530    /// ```
3531    /// </details>
3532    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3533    pub struct OptionsInfoOption {
3534        #[serde(rename = "Advanced")]
3535        pub advanced: bool,
3536        ///Default value for this option.
3537        #[serde(rename = "Default")]
3538        pub default: OptionsInfoOptionDefault,
3539        #[serde(rename = "DefaultStr")]
3540        pub default_str: ::std::string::String,
3541        #[serde(
3542            rename = "Examples",
3543            default,
3544            skip_serializing_if = "::std::vec::Vec::is_empty"
3545        )]
3546        pub examples: ::std::vec::Vec<OptionsInfoOptionExample>,
3547        #[serde(rename = "Exclusive")]
3548        pub exclusive: bool,
3549        #[serde(rename = "FieldName")]
3550        pub field_name: ::std::string::String,
3551        #[serde(
3552            rename = "Groups",
3553            default,
3554            skip_serializing_if = "::std::option::Option::is_none"
3555        )]
3556        pub groups: ::std::option::Option<::std::string::String>,
3557        #[serde(rename = "Help")]
3558        pub help: ::std::string::String,
3559        #[serde(rename = "Hide")]
3560        pub hide: i64,
3561        #[serde(rename = "IsPassword")]
3562        pub is_password: bool,
3563        #[serde(rename = "Name")]
3564        pub name: ::std::string::String,
3565        #[serde(rename = "NoPrefix")]
3566        pub no_prefix: bool,
3567        #[serde(rename = "Required")]
3568        pub required: bool,
3569        #[serde(rename = "Sensitive")]
3570        pub sensitive: bool,
3571        #[serde(
3572            rename = "ShortOpt",
3573            default,
3574            skip_serializing_if = "::std::option::Option::is_none"
3575        )]
3576        pub short_opt: ::std::option::Option<::std::string::String>,
3577        #[serde(rename = "Type")]
3578        pub type_: ::std::string::String,
3579        #[serde(rename = "Value")]
3580        pub value: ::std::option::Option<OptionsInfoOptionValue>,
3581        #[serde(rename = "ValueStr")]
3582        pub value_str: ::std::string::String,
3583    }
3584
3585    impl ::std::convert::From<&OptionsInfoOption> for OptionsInfoOption {
3586        fn from(value: &OptionsInfoOption) -> Self {
3587            value.clone()
3588        }
3589    }
3590
3591    ///Default value for this option.
3592    ///
3593    /// <details><summary>JSON schema</summary>
3594    ///
3595    /// ```json
3596    ///{
3597    ///  "description": "Default value for this option.",
3598    ///  "anyOf": [
3599    ///    {
3600    ///      "type": "array",
3601    ///      "items": {
3602    ///        "type": "string"
3603    ///      }
3604    ///    },
3605    ///    {
3606    ///      "type": "boolean"
3607    ///    },
3608    ///    {
3609    ///      "type": "number"
3610    ///    },
3611    ///    {
3612    ///      "type": "string"
3613    ///    },
3614    ///    {
3615    ///      "type": "object",
3616    ///      "required": [
3617    ///        "Valid",
3618    ///        "Value"
3619    ///      ],
3620    ///      "properties": {
3621    ///        "Valid": {
3622    ///          "type": "boolean"
3623    ///        },
3624    ///        "Value": {
3625    ///          "type": "boolean"
3626    ///        }
3627    ///      },
3628    ///      "additionalProperties": false
3629    ///    }
3630    ///  ]
3631    ///}
3632    /// ```
3633    /// </details>
3634    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3635    #[serde(untagged, deny_unknown_fields)]
3636    pub enum OptionsInfoOptionDefault {
3637        Variant0(::std::vec::Vec<::std::string::String>),
3638        Variant1(bool),
3639        Variant2(f64),
3640        Variant3(::std::string::String),
3641        Variant4 {
3642            #[serde(rename = "Valid")]
3643            valid: bool,
3644            #[serde(rename = "Value")]
3645            value: bool,
3646        },
3647    }
3648
3649    impl ::std::convert::From<&Self> for OptionsInfoOptionDefault {
3650        fn from(value: &OptionsInfoOptionDefault) -> Self {
3651            value.clone()
3652        }
3653    }
3654
3655    impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionDefault {
3656        fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
3657            Self::Variant0(value)
3658        }
3659    }
3660
3661    impl ::std::convert::From<bool> for OptionsInfoOptionDefault {
3662        fn from(value: bool) -> Self {
3663            Self::Variant1(value)
3664        }
3665    }
3666
3667    impl ::std::convert::From<f64> for OptionsInfoOptionDefault {
3668        fn from(value: f64) -> Self {
3669            Self::Variant2(value)
3670        }
3671    }
3672
3673    ///`OptionsInfoOptionExample`
3674    ///
3675    /// <details><summary>JSON schema</summary>
3676    ///
3677    /// ```json
3678    ///{
3679    ///  "type": "object",
3680    ///  "required": [
3681    ///    "Help",
3682    ///    "Value"
3683    ///  ],
3684    ///  "properties": {
3685    ///    "Help": {
3686    ///      "type": "string"
3687    ///    },
3688    ///    "Value": {
3689    ///      "type": "string"
3690    ///    }
3691    ///  },
3692    ///  "additionalProperties": true
3693    ///}
3694    /// ```
3695    /// </details>
3696    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3697    pub struct OptionsInfoOptionExample {
3698        #[serde(rename = "Help")]
3699        pub help: ::std::string::String,
3700        #[serde(rename = "Value")]
3701        pub value: ::std::string::String,
3702    }
3703
3704    impl ::std::convert::From<&OptionsInfoOptionExample> for OptionsInfoOptionExample {
3705        fn from(value: &OptionsInfoOptionExample) -> Self {
3706            value.clone()
3707        }
3708    }
3709
3710    ///`OptionsInfoOptionValue`
3711    ///
3712    /// <details><summary>JSON schema</summary>
3713    ///
3714    /// ```json
3715    ///{
3716    ///  "anyOf": [
3717    ///    {
3718    ///      "type": "boolean"
3719    ///    },
3720    ///    {
3721    ///      "type": "number"
3722    ///    }
3723    ///  ]
3724    ///}
3725    /// ```
3726    /// </details>
3727    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3728    #[serde(untagged)]
3729    pub enum OptionsInfoOptionValue {
3730        Variant0(bool),
3731        Variant1(f64),
3732    }
3733
3734    impl ::std::convert::From<&Self> for OptionsInfoOptionValue {
3735        fn from(value: &OptionsInfoOptionValue) -> Self {
3736            value.clone()
3737        }
3738    }
3739
3740    impl ::std::str::FromStr for OptionsInfoOptionValue {
3741        type Err = self::error::ConversionError;
3742        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3743            if let Ok(v) = value.parse() {
3744                Ok(Self::Variant0(v))
3745            } else if let Ok(v) = value.parse() {
3746                Ok(Self::Variant1(v))
3747            } else {
3748                Err("string conversion failed for all variants".into())
3749            }
3750        }
3751    }
3752
3753    impl ::std::convert::TryFrom<&str> for OptionsInfoOptionValue {
3754        type Error = self::error::ConversionError;
3755        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3756            value.parse()
3757        }
3758    }
3759
3760    impl ::std::convert::TryFrom<&::std::string::String> for OptionsInfoOptionValue {
3761        type Error = self::error::ConversionError;
3762        fn try_from(
3763            value: &::std::string::String,
3764        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3765            value.parse()
3766        }
3767    }
3768
3769    impl ::std::convert::TryFrom<::std::string::String> for OptionsInfoOptionValue {
3770        type Error = self::error::ConversionError;
3771        fn try_from(
3772            value: ::std::string::String,
3773        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3774            value.parse()
3775        }
3776    }
3777
3778    impl ::std::fmt::Display for OptionsInfoOptionValue {
3779        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3780            match self {
3781                Self::Variant0(x) => x.fmt(f),
3782                Self::Variant1(x) => x.fmt(f),
3783            }
3784        }
3785    }
3786
3787    impl ::std::convert::From<bool> for OptionsInfoOptionValue {
3788        fn from(value: bool) -> Self {
3789            Self::Variant0(value)
3790        }
3791    }
3792
3793    impl ::std::convert::From<f64> for OptionsInfoOptionValue {
3794        fn from(value: f64) -> Self {
3795            Self::Variant1(value)
3796        }
3797    }
3798
3799    ///`OptionsInfoResponse`
3800    ///
3801    /// <details><summary>JSON schema</summary>
3802    ///
3803    /// ```json
3804    ///{
3805    ///  "type": "object",
3806    ///  "required": [
3807    ///    "dlna",
3808    ///    "filter",
3809    ///    "ftp",
3810    ///    "http",
3811    ///    "log",
3812    ///    "main",
3813    ///    "mount",
3814    ///    "nfs",
3815    ///    "proxy",
3816    ///    "rc",
3817    ///    "restic",
3818    ///    "s3",
3819    ///    "sftp",
3820    ///    "vfs",
3821    ///    "webdav"
3822    ///  ],
3823    ///  "properties": {
3824    ///    "dlna": {
3825    ///      "type": "array",
3826    ///      "items": {
3827    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3828    ///      }
3829    ///    },
3830    ///    "filter": {
3831    ///      "type": "array",
3832    ///      "items": {
3833    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3834    ///      }
3835    ///    },
3836    ///    "ftp": {
3837    ///      "type": "array",
3838    ///      "items": {
3839    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3840    ///      }
3841    ///    },
3842    ///    "http": {
3843    ///      "type": "array",
3844    ///      "items": {
3845    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3846    ///      }
3847    ///    },
3848    ///    "log": {
3849    ///      "type": "array",
3850    ///      "items": {
3851    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3852    ///      }
3853    ///    },
3854    ///    "main": {
3855    ///      "type": "array",
3856    ///      "items": {
3857    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3858    ///      }
3859    ///    },
3860    ///    "mount": {
3861    ///      "type": "array",
3862    ///      "items": {
3863    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3864    ///      }
3865    ///    },
3866    ///    "nfs": {
3867    ///      "type": "array",
3868    ///      "items": {
3869    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3870    ///      }
3871    ///    },
3872    ///    "proxy": {
3873    ///      "type": "array",
3874    ///      "items": {
3875    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3876    ///      }
3877    ///    },
3878    ///    "rc": {
3879    ///      "type": "array",
3880    ///      "items": {
3881    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3882    ///      }
3883    ///    },
3884    ///    "restic": {
3885    ///      "type": "array",
3886    ///      "items": {
3887    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3888    ///      }
3889    ///    },
3890    ///    "s3": {
3891    ///      "type": "array",
3892    ///      "items": {
3893    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3894    ///      }
3895    ///    },
3896    ///    "sftp": {
3897    ///      "type": "array",
3898    ///      "items": {
3899    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3900    ///      }
3901    ///    },
3902    ///    "vfs": {
3903    ///      "type": "array",
3904    ///      "items": {
3905    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3906    ///      }
3907    ///    },
3908    ///    "webdav": {
3909    ///      "type": "array",
3910    ///      "items": {
3911    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3912    ///      }
3913    ///    }
3914    ///  },
3915    ///  "additionalProperties": {
3916    ///    "type": "array",
3917    ///    "items": {
3918    ///      "$ref": "#/components/schemas/OptionsInfoOption"
3919    ///    }
3920    ///  }
3921    ///}
3922    /// ```
3923    /// </details>
3924    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3925    pub struct OptionsInfoResponse {
3926        pub dlna: ::std::vec::Vec<OptionsInfoOption>,
3927        pub filter: ::std::vec::Vec<OptionsInfoOption>,
3928        pub ftp: ::std::vec::Vec<OptionsInfoOption>,
3929        pub http: ::std::vec::Vec<OptionsInfoOption>,
3930        pub log: ::std::vec::Vec<OptionsInfoOption>,
3931        pub main: ::std::vec::Vec<OptionsInfoOption>,
3932        pub mount: ::std::vec::Vec<OptionsInfoOption>,
3933        pub nfs: ::std::vec::Vec<OptionsInfoOption>,
3934        pub proxy: ::std::vec::Vec<OptionsInfoOption>,
3935        pub rc: ::std::vec::Vec<OptionsInfoOption>,
3936        pub restic: ::std::vec::Vec<OptionsInfoOption>,
3937        pub s3: ::std::vec::Vec<OptionsInfoOption>,
3938        pub sftp: ::std::vec::Vec<OptionsInfoOption>,
3939        pub vfs: ::std::vec::Vec<OptionsInfoOption>,
3940        pub webdav: ::std::vec::Vec<OptionsInfoOption>,
3941        #[serde(flatten)]
3942        pub extra:
3943            ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<OptionsInfoOption>>,
3944    }
3945
3946    impl ::std::convert::From<&OptionsInfoResponse> for OptionsInfoResponse {
3947        fn from(value: &OptionsInfoResponse) -> Self {
3948            value.clone()
3949        }
3950    }
3951
3952    ///`OptionsLocalResponse`
3953    ///
3954    /// <details><summary>JSON schema</summary>
3955    ///
3956    /// ```json
3957    ///{
3958    ///  "type": "object",
3959    ///  "required": [
3960    ///    "config",
3961    ///    "filter"
3962    ///  ],
3963    ///  "properties": {
3964    ///    "config": {
3965    ///      "type": "object",
3966    ///      "required": [
3967    ///        "AskPassword",
3968    ///        "AutoConfirm",
3969    ///        "BackupDir",
3970    ///        "BindAddr",
3971    ///        "BufferSize",
3972    ///        "BwLimit",
3973    ///        "BwLimitFile",
3974    ///        "CaCert",
3975    ///        "CheckFirst",
3976    ///        "CheckSum",
3977    ///        "Checkers",
3978    ///        "ClientCert",
3979    ///        "ClientKey",
3980    ///        "CompareDest",
3981    ///        "ConnectTimeout",
3982    ///        "Cookie",
3983    ///        "CopyDest",
3984    ///        "CutoffMode",
3985    ///        "DataRateUnit",
3986    ///        "DefaultTime",
3987    ///        "DeleteMode",
3988    ///        "DisableFeatures",
3989    ///        "DisableHTTP2",
3990    ///        "DisableHTTPKeepAlives",
3991    ///        "DownloadHeaders",
3992    ///        "DryRun",
3993    ///        "Dump",
3994    ///        "ErrorOnNoTransfer",
3995    ///        "ExpectContinueTimeout",
3996    ///        "FixCase",
3997    ///        "FsCacheExpireDuration",
3998    ///        "FsCacheExpireInterval",
3999    ///        "Headers",
4000    ///        "HumanReadable",
4001    ///        "IgnoreCaseSync",
4002    ///        "IgnoreChecksum",
4003    ///        "IgnoreErrors",
4004    ///        "IgnoreExisting",
4005    ///        "IgnoreSize",
4006    ///        "IgnoreTimes",
4007    ///        "Immutable",
4008    ///        "Inplace",
4009    ///        "InsecureSkipVerify",
4010    ///        "Interactive",
4011    ///        "KvLockTime",
4012    ///        "Links",
4013    ///        "LogLevel",
4014    ///        "LowLevelRetries",
4015    ///        "MaxBacklog",
4016    ///        "MaxBufferMemory",
4017    ///        "MaxDelete",
4018    ///        "MaxDeleteSize",
4019    ///        "MaxDepth",
4020    ///        "MaxDuration",
4021    ///        "MaxStatsGroups",
4022    ///        "MaxTransfer",
4023    ///        "Metadata",
4024    ///        "MetadataMapper",
4025    ///        "MetadataSet",
4026    ///        "ModifyWindow",
4027    ///        "MultiThreadChunkSize",
4028    ///        "MultiThreadCutoff",
4029    ///        "MultiThreadSet",
4030    ///        "MultiThreadStreams",
4031    ///        "MultiThreadWriteBufferSize",
4032    ///        "NoCheckDest",
4033    ///        "NoConsole",
4034    ///        "NoGzip",
4035    ///        "NoTraverse",
4036    ///        "NoUnicodeNormalization",
4037    ///        "NoUpdateDirModTime",
4038    ///        "NoUpdateModTime",
4039    ///        "OrderBy",
4040    ///        "PartialSuffix",
4041    ///        "PasswordCommand",
4042    ///        "Progress",
4043    ///        "ProgressTerminalTitle",
4044    ///        "RefreshTimes",
4045    ///        "Retries",
4046    ///        "RetriesInterval",
4047    ///        "ServerSideAcrossConfigs",
4048    ///        "SizeOnly",
4049    ///        "StatsFileNameLength",
4050    ///        "StatsLogLevel",
4051    ///        "StatsOneLine",
4052    ///        "StatsOneLineDate",
4053    ///        "StatsOneLineDateFormat",
4054    ///        "StreamingUploadCutoff",
4055    ///        "Suffix",
4056    ///        "SuffixKeepExtension",
4057    ///        "TPSLimit",
4058    ///        "TPSLimitBurst",
4059    ///        "TerminalColorMode",
4060    ///        "Timeout",
4061    ///        "TrackRenames",
4062    ///        "TrackRenamesStrategy",
4063    ///        "TrafficClass",
4064    ///        "Transfers",
4065    ///        "UpdateOlder",
4066    ///        "UploadHeaders",
4067    ///        "UseJSONLog",
4068    ///        "UseListR",
4069    ///        "UseMmap",
4070    ///        "UseServerModTime",
4071    ///        "UserAgent"
4072    ///      ],
4073    ///      "properties": {
4074    ///        "AskPassword": {
4075    ///          "type": "boolean"
4076    ///        },
4077    ///        "AutoConfirm": {
4078    ///          "type": "boolean"
4079    ///        },
4080    ///        "BackupDir": {
4081    ///          "type": "string"
4082    ///        },
4083    ///        "BindAddr": {
4084    ///          "type": "string"
4085    ///        },
4086    ///        "BufferSize": {
4087    ///          "type": "number"
4088    ///        },
4089    ///        "BwLimit": {
4090    ///          "type": "string"
4091    ///        },
4092    ///        "BwLimitFile": {
4093    ///          "type": "string"
4094    ///        },
4095    ///        "CaCert": {
4096    ///          "type": "array",
4097    ///          "items": {
4098    ///            "type": "string"
4099    ///          }
4100    ///        },
4101    ///        "CheckFirst": {
4102    ///          "type": "boolean"
4103    ///        },
4104    ///        "CheckSum": {
4105    ///          "type": "boolean"
4106    ///        },
4107    ///        "Checkers": {
4108    ///          "type": "number"
4109    ///        },
4110    ///        "ClientCert": {
4111    ///          "type": "string"
4112    ///        },
4113    ///        "ClientKey": {
4114    ///          "type": "string"
4115    ///        },
4116    ///        "CompareDest": {
4117    ///          "type": "array",
4118    ///          "items": {
4119    ///            "type": "string"
4120    ///          }
4121    ///        },
4122    ///        "ConnectTimeout": {
4123    ///          "type": "number"
4124    ///        },
4125    ///        "Cookie": {
4126    ///          "type": "boolean"
4127    ///        },
4128    ///        "CopyDest": {
4129    ///          "type": "array",
4130    ///          "items": {
4131    ///            "type": "string"
4132    ///          }
4133    ///        },
4134    ///        "CutoffMode": {
4135    ///          "type": "string"
4136    ///        },
4137    ///        "DataRateUnit": {
4138    ///          "type": "string"
4139    ///        },
4140    ///        "DefaultTime": {
4141    ///          "type": "string"
4142    ///        },
4143    ///        "DeleteMode": {
4144    ///          "type": "number"
4145    ///        },
4146    ///        "DisableFeatures": {
4147    ///          "type": [
4148    ///            "string",
4149    ///            "null"
4150    ///          ],
4151    ///          "format": "null"
4152    ///        },
4153    ///        "DisableHTTP2": {
4154    ///          "type": "boolean"
4155    ///        },
4156    ///        "DisableHTTPKeepAlives": {
4157    ///          "type": "boolean"
4158    ///        },
4159    ///        "DownloadHeaders": {
4160    ///          "type": [
4161    ///            "string",
4162    ///            "null"
4163    ///          ],
4164    ///          "format": "null"
4165    ///        },
4166    ///        "DryRun": {
4167    ///          "type": "boolean"
4168    ///        },
4169    ///        "Dump": {
4170    ///          "type": "string"
4171    ///        },
4172    ///        "ErrorOnNoTransfer": {
4173    ///          "type": "boolean"
4174    ///        },
4175    ///        "ExpectContinueTimeout": {
4176    ///          "type": "number"
4177    ///        },
4178    ///        "FixCase": {
4179    ///          "type": "boolean"
4180    ///        },
4181    ///        "FsCacheExpireDuration": {
4182    ///          "type": "number"
4183    ///        },
4184    ///        "FsCacheExpireInterval": {
4185    ///          "type": "number"
4186    ///        },
4187    ///        "Headers": {
4188    ///          "type": [
4189    ///            "string",
4190    ///            "null"
4191    ///          ],
4192    ///          "format": "null"
4193    ///        },
4194    ///        "HumanReadable": {
4195    ///          "type": "boolean"
4196    ///        },
4197    ///        "IgnoreCaseSync": {
4198    ///          "type": "boolean"
4199    ///        },
4200    ///        "IgnoreChecksum": {
4201    ///          "type": "boolean"
4202    ///        },
4203    ///        "IgnoreErrors": {
4204    ///          "type": "boolean"
4205    ///        },
4206    ///        "IgnoreExisting": {
4207    ///          "type": "boolean"
4208    ///        },
4209    ///        "IgnoreSize": {
4210    ///          "type": "boolean"
4211    ///        },
4212    ///        "IgnoreTimes": {
4213    ///          "type": "boolean"
4214    ///        },
4215    ///        "Immutable": {
4216    ///          "type": "boolean"
4217    ///        },
4218    ///        "Inplace": {
4219    ///          "type": "boolean"
4220    ///        },
4221    ///        "InsecureSkipVerify": {
4222    ///          "type": "boolean"
4223    ///        },
4224    ///        "Interactive": {
4225    ///          "type": "boolean"
4226    ///        },
4227    ///        "KvLockTime": {
4228    ///          "type": "number"
4229    ///        },
4230    ///        "Links": {
4231    ///          "type": "boolean"
4232    ///        },
4233    ///        "LogLevel": {
4234    ///          "type": "string"
4235    ///        },
4236    ///        "LowLevelRetries": {
4237    ///          "type": "number"
4238    ///        },
4239    ///        "MaxBacklog": {
4240    ///          "type": "number"
4241    ///        },
4242    ///        "MaxBufferMemory": {
4243    ///          "type": "number"
4244    ///        },
4245    ///        "MaxDelete": {
4246    ///          "type": "number"
4247    ///        },
4248    ///        "MaxDeleteSize": {
4249    ///          "type": "number"
4250    ///        },
4251    ///        "MaxDepth": {
4252    ///          "type": "number"
4253    ///        },
4254    ///        "MaxDuration": {
4255    ///          "type": "number"
4256    ///        },
4257    ///        "MaxStatsGroups": {
4258    ///          "type": "number"
4259    ///        },
4260    ///        "MaxTransfer": {
4261    ///          "type": "number"
4262    ///        },
4263    ///        "Metadata": {
4264    ///          "type": "boolean"
4265    ///        },
4266    ///        "MetadataMapper": {
4267    ///          "type": [
4268    ///            "string",
4269    ///            "null"
4270    ///          ],
4271    ///          "format": "null"
4272    ///        },
4273    ///        "MetadataSet": {
4274    ///          "type": [
4275    ///            "string",
4276    ///            "null"
4277    ///          ],
4278    ///          "format": "null"
4279    ///        },
4280    ///        "ModifyWindow": {
4281    ///          "type": "number"
4282    ///        },
4283    ///        "MultiThreadChunkSize": {
4284    ///          "type": "number"
4285    ///        },
4286    ///        "MultiThreadCutoff": {
4287    ///          "type": "number"
4288    ///        },
4289    ///        "MultiThreadSet": {
4290    ///          "type": "boolean"
4291    ///        },
4292    ///        "MultiThreadStreams": {
4293    ///          "type": "number"
4294    ///        },
4295    ///        "MultiThreadWriteBufferSize": {
4296    ///          "type": "number"
4297    ///        },
4298    ///        "NoCheckDest": {
4299    ///          "type": "boolean"
4300    ///        },
4301    ///        "NoConsole": {
4302    ///          "type": "boolean"
4303    ///        },
4304    ///        "NoGzip": {
4305    ///          "type": "boolean"
4306    ///        },
4307    ///        "NoTraverse": {
4308    ///          "type": "boolean"
4309    ///        },
4310    ///        "NoUnicodeNormalization": {
4311    ///          "type": "boolean"
4312    ///        },
4313    ///        "NoUpdateDirModTime": {
4314    ///          "type": "boolean"
4315    ///        },
4316    ///        "NoUpdateModTime": {
4317    ///          "type": "boolean"
4318    ///        },
4319    ///        "OrderBy": {
4320    ///          "type": "string"
4321    ///        },
4322    ///        "PartialSuffix": {
4323    ///          "type": "string"
4324    ///        },
4325    ///        "PasswordCommand": {
4326    ///          "type": [
4327    ///            "string",
4328    ///            "null"
4329    ///          ],
4330    ///          "format": "null"
4331    ///        },
4332    ///        "Progress": {
4333    ///          "type": "boolean"
4334    ///        },
4335    ///        "ProgressTerminalTitle": {
4336    ///          "type": "boolean"
4337    ///        },
4338    ///        "RefreshTimes": {
4339    ///          "type": "boolean"
4340    ///        },
4341    ///        "Retries": {
4342    ///          "type": "number"
4343    ///        },
4344    ///        "RetriesInterval": {
4345    ///          "type": "number"
4346    ///        },
4347    ///        "ServerSideAcrossConfigs": {
4348    ///          "type": "boolean"
4349    ///        },
4350    ///        "SizeOnly": {
4351    ///          "type": "boolean"
4352    ///        },
4353    ///        "StatsFileNameLength": {
4354    ///          "type": "number"
4355    ///        },
4356    ///        "StatsLogLevel": {
4357    ///          "type": "string"
4358    ///        },
4359    ///        "StatsOneLine": {
4360    ///          "type": "boolean"
4361    ///        },
4362    ///        "StatsOneLineDate": {
4363    ///          "type": "boolean"
4364    ///        },
4365    ///        "StatsOneLineDateFormat": {
4366    ///          "type": "string"
4367    ///        },
4368    ///        "StreamingUploadCutoff": {
4369    ///          "type": "number"
4370    ///        },
4371    ///        "Suffix": {
4372    ///          "type": "string"
4373    ///        },
4374    ///        "SuffixKeepExtension": {
4375    ///          "type": "boolean"
4376    ///        },
4377    ///        "TPSLimit": {
4378    ///          "type": "number"
4379    ///        },
4380    ///        "TPSLimitBurst": {
4381    ///          "type": "number"
4382    ///        },
4383    ///        "TerminalColorMode": {
4384    ///          "type": "string"
4385    ///        },
4386    ///        "Timeout": {
4387    ///          "type": "number"
4388    ///        },
4389    ///        "TrackRenames": {
4390    ///          "type": "boolean"
4391    ///        },
4392    ///        "TrackRenamesStrategy": {
4393    ///          "type": "string"
4394    ///        },
4395    ///        "TrafficClass": {
4396    ///          "type": "number"
4397    ///        },
4398    ///        "Transfers": {
4399    ///          "type": "number"
4400    ///        },
4401    ///        "UpdateOlder": {
4402    ///          "type": "boolean"
4403    ///        },
4404    ///        "UploadHeaders": {
4405    ///          "type": [
4406    ///            "string",
4407    ///            "null"
4408    ///          ],
4409    ///          "format": "null"
4410    ///        },
4411    ///        "UseJSONLog": {
4412    ///          "type": "boolean"
4413    ///        },
4414    ///        "UseListR": {
4415    ///          "type": "boolean"
4416    ///        },
4417    ///        "UseMmap": {
4418    ///          "type": "boolean"
4419    ///        },
4420    ///        "UseServerModTime": {
4421    ///          "type": "boolean"
4422    ///        },
4423    ///        "UserAgent": {
4424    ///          "type": "string"
4425    ///        }
4426    ///      }
4427    ///    },
4428    ///    "filter": {
4429    ///      "type": "object",
4430    ///      "required": [
4431    ///        "DeleteExcluded",
4432    ///        "ExcludeFile",
4433    ///        "ExcludeFrom",
4434    ///        "ExcludeRule",
4435    ///        "FilesFrom",
4436    ///        "FilesFromRaw",
4437    ///        "FilterFrom",
4438    ///        "FilterRule",
4439    ///        "HashFilter",
4440    ///        "IgnoreCase",
4441    ///        "IncludeFrom",
4442    ///        "IncludeRule",
4443    ///        "MaxAge",
4444    ///        "MaxSize",
4445    ///        "MetaRules",
4446    ///        "MinAge",
4447    ///        "MinSize"
4448    ///      ],
4449    ///      "properties": {
4450    ///        "DeleteExcluded": {
4451    ///          "type": "boolean"
4452    ///        },
4453    ///        "ExcludeFile": {
4454    ///          "type": "array",
4455    ///          "items": {
4456    ///            "type": "string"
4457    ///          }
4458    ///        },
4459    ///        "ExcludeFrom": {
4460    ///          "type": "array",
4461    ///          "items": {
4462    ///            "type": "string"
4463    ///          }
4464    ///        },
4465    ///        "ExcludeRule": {
4466    ///          "type": "array",
4467    ///          "items": {
4468    ///            "type": "string"
4469    ///          }
4470    ///        },
4471    ///        "FilesFrom": {
4472    ///          "type": "array",
4473    ///          "items": {
4474    ///            "type": "string"
4475    ///          }
4476    ///        },
4477    ///        "FilesFromRaw": {
4478    ///          "type": "array",
4479    ///          "items": {
4480    ///            "type": "string"
4481    ///          }
4482    ///        },
4483    ///        "FilterFrom": {
4484    ///          "type": "array",
4485    ///          "items": {
4486    ///            "type": "string"
4487    ///          }
4488    ///        },
4489    ///        "FilterRule": {
4490    ///          "type": "array",
4491    ///          "items": {
4492    ///            "type": "string"
4493    ///          }
4494    ///        },
4495    ///        "HashFilter": {
4496    ///          "type": "string"
4497    ///        },
4498    ///        "IgnoreCase": {
4499    ///          "type": "boolean"
4500    ///        },
4501    ///        "IncludeFrom": {
4502    ///          "type": "array",
4503    ///          "items": {
4504    ///            "type": "string"
4505    ///          }
4506    ///        },
4507    ///        "IncludeRule": {
4508    ///          "type": "array",
4509    ///          "items": {
4510    ///            "type": "string"
4511    ///          }
4512    ///        },
4513    ///        "MaxAge": {
4514    ///          "type": "number"
4515    ///        },
4516    ///        "MaxSize": {
4517    ///          "type": "number"
4518    ///        },
4519    ///        "MetaRules": {
4520    ///          "type": "object",
4521    ///          "required": [
4522    ///            "ExcludeFrom",
4523    ///            "ExcludeRule",
4524    ///            "FilterFrom",
4525    ///            "FilterRule",
4526    ///            "IncludeFrom",
4527    ///            "IncludeRule"
4528    ///          ],
4529    ///          "properties": {
4530    ///            "ExcludeFrom": {
4531    ///              "type": "array",
4532    ///              "items": {
4533    ///                "type": "string"
4534    ///              }
4535    ///            },
4536    ///            "ExcludeRule": {
4537    ///              "type": "array",
4538    ///              "items": {
4539    ///                "type": "string"
4540    ///              }
4541    ///            },
4542    ///            "FilterFrom": {
4543    ///              "type": "array",
4544    ///              "items": {
4545    ///                "type": "string"
4546    ///              }
4547    ///            },
4548    ///            "FilterRule": {
4549    ///              "type": "array",
4550    ///              "items": {
4551    ///                "type": "string"
4552    ///              }
4553    ///            },
4554    ///            "IncludeFrom": {
4555    ///              "type": "array",
4556    ///              "items": {
4557    ///                "type": "string"
4558    ///              }
4559    ///            },
4560    ///            "IncludeRule": {
4561    ///              "type": "array",
4562    ///              "items": {
4563    ///                "type": "string"
4564    ///              }
4565    ///            }
4566    ///          }
4567    ///        },
4568    ///        "MinAge": {
4569    ///          "type": "number"
4570    ///        },
4571    ///        "MinSize": {
4572    ///          "type": "number"
4573    ///        }
4574    ///      }
4575    ///    }
4576    ///  }
4577    ///}
4578    /// ```
4579    /// </details>
4580    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4581    pub struct OptionsLocalResponse {
4582        pub config: OptionsLocalResponseConfig,
4583        pub filter: OptionsLocalResponseFilter,
4584    }
4585
4586    impl ::std::convert::From<&OptionsLocalResponse> for OptionsLocalResponse {
4587        fn from(value: &OptionsLocalResponse) -> Self {
4588            value.clone()
4589        }
4590    }
4591
4592    ///`OptionsLocalResponseConfig`
4593    ///
4594    /// <details><summary>JSON schema</summary>
4595    ///
4596    /// ```json
4597    ///{
4598    ///  "type": "object",
4599    ///  "required": [
4600    ///    "AskPassword",
4601    ///    "AutoConfirm",
4602    ///    "BackupDir",
4603    ///    "BindAddr",
4604    ///    "BufferSize",
4605    ///    "BwLimit",
4606    ///    "BwLimitFile",
4607    ///    "CaCert",
4608    ///    "CheckFirst",
4609    ///    "CheckSum",
4610    ///    "Checkers",
4611    ///    "ClientCert",
4612    ///    "ClientKey",
4613    ///    "CompareDest",
4614    ///    "ConnectTimeout",
4615    ///    "Cookie",
4616    ///    "CopyDest",
4617    ///    "CutoffMode",
4618    ///    "DataRateUnit",
4619    ///    "DefaultTime",
4620    ///    "DeleteMode",
4621    ///    "DisableFeatures",
4622    ///    "DisableHTTP2",
4623    ///    "DisableHTTPKeepAlives",
4624    ///    "DownloadHeaders",
4625    ///    "DryRun",
4626    ///    "Dump",
4627    ///    "ErrorOnNoTransfer",
4628    ///    "ExpectContinueTimeout",
4629    ///    "FixCase",
4630    ///    "FsCacheExpireDuration",
4631    ///    "FsCacheExpireInterval",
4632    ///    "Headers",
4633    ///    "HumanReadable",
4634    ///    "IgnoreCaseSync",
4635    ///    "IgnoreChecksum",
4636    ///    "IgnoreErrors",
4637    ///    "IgnoreExisting",
4638    ///    "IgnoreSize",
4639    ///    "IgnoreTimes",
4640    ///    "Immutable",
4641    ///    "Inplace",
4642    ///    "InsecureSkipVerify",
4643    ///    "Interactive",
4644    ///    "KvLockTime",
4645    ///    "Links",
4646    ///    "LogLevel",
4647    ///    "LowLevelRetries",
4648    ///    "MaxBacklog",
4649    ///    "MaxBufferMemory",
4650    ///    "MaxDelete",
4651    ///    "MaxDeleteSize",
4652    ///    "MaxDepth",
4653    ///    "MaxDuration",
4654    ///    "MaxStatsGroups",
4655    ///    "MaxTransfer",
4656    ///    "Metadata",
4657    ///    "MetadataMapper",
4658    ///    "MetadataSet",
4659    ///    "ModifyWindow",
4660    ///    "MultiThreadChunkSize",
4661    ///    "MultiThreadCutoff",
4662    ///    "MultiThreadSet",
4663    ///    "MultiThreadStreams",
4664    ///    "MultiThreadWriteBufferSize",
4665    ///    "NoCheckDest",
4666    ///    "NoConsole",
4667    ///    "NoGzip",
4668    ///    "NoTraverse",
4669    ///    "NoUnicodeNormalization",
4670    ///    "NoUpdateDirModTime",
4671    ///    "NoUpdateModTime",
4672    ///    "OrderBy",
4673    ///    "PartialSuffix",
4674    ///    "PasswordCommand",
4675    ///    "Progress",
4676    ///    "ProgressTerminalTitle",
4677    ///    "RefreshTimes",
4678    ///    "Retries",
4679    ///    "RetriesInterval",
4680    ///    "ServerSideAcrossConfigs",
4681    ///    "SizeOnly",
4682    ///    "StatsFileNameLength",
4683    ///    "StatsLogLevel",
4684    ///    "StatsOneLine",
4685    ///    "StatsOneLineDate",
4686    ///    "StatsOneLineDateFormat",
4687    ///    "StreamingUploadCutoff",
4688    ///    "Suffix",
4689    ///    "SuffixKeepExtension",
4690    ///    "TPSLimit",
4691    ///    "TPSLimitBurst",
4692    ///    "TerminalColorMode",
4693    ///    "Timeout",
4694    ///    "TrackRenames",
4695    ///    "TrackRenamesStrategy",
4696    ///    "TrafficClass",
4697    ///    "Transfers",
4698    ///    "UpdateOlder",
4699    ///    "UploadHeaders",
4700    ///    "UseJSONLog",
4701    ///    "UseListR",
4702    ///    "UseMmap",
4703    ///    "UseServerModTime",
4704    ///    "UserAgent"
4705    ///  ],
4706    ///  "properties": {
4707    ///    "AskPassword": {
4708    ///      "type": "boolean"
4709    ///    },
4710    ///    "AutoConfirm": {
4711    ///      "type": "boolean"
4712    ///    },
4713    ///    "BackupDir": {
4714    ///      "type": "string"
4715    ///    },
4716    ///    "BindAddr": {
4717    ///      "type": "string"
4718    ///    },
4719    ///    "BufferSize": {
4720    ///      "type": "number"
4721    ///    },
4722    ///    "BwLimit": {
4723    ///      "type": "string"
4724    ///    },
4725    ///    "BwLimitFile": {
4726    ///      "type": "string"
4727    ///    },
4728    ///    "CaCert": {
4729    ///      "type": "array",
4730    ///      "items": {
4731    ///        "type": "string"
4732    ///      }
4733    ///    },
4734    ///    "CheckFirst": {
4735    ///      "type": "boolean"
4736    ///    },
4737    ///    "CheckSum": {
4738    ///      "type": "boolean"
4739    ///    },
4740    ///    "Checkers": {
4741    ///      "type": "number"
4742    ///    },
4743    ///    "ClientCert": {
4744    ///      "type": "string"
4745    ///    },
4746    ///    "ClientKey": {
4747    ///      "type": "string"
4748    ///    },
4749    ///    "CompareDest": {
4750    ///      "type": "array",
4751    ///      "items": {
4752    ///        "type": "string"
4753    ///      }
4754    ///    },
4755    ///    "ConnectTimeout": {
4756    ///      "type": "number"
4757    ///    },
4758    ///    "Cookie": {
4759    ///      "type": "boolean"
4760    ///    },
4761    ///    "CopyDest": {
4762    ///      "type": "array",
4763    ///      "items": {
4764    ///        "type": "string"
4765    ///      }
4766    ///    },
4767    ///    "CutoffMode": {
4768    ///      "type": "string"
4769    ///    },
4770    ///    "DataRateUnit": {
4771    ///      "type": "string"
4772    ///    },
4773    ///    "DefaultTime": {
4774    ///      "type": "string"
4775    ///    },
4776    ///    "DeleteMode": {
4777    ///      "type": "number"
4778    ///    },
4779    ///    "DisableFeatures": {
4780    ///      "type": [
4781    ///        "string",
4782    ///        "null"
4783    ///      ],
4784    ///      "format": "null"
4785    ///    },
4786    ///    "DisableHTTP2": {
4787    ///      "type": "boolean"
4788    ///    },
4789    ///    "DisableHTTPKeepAlives": {
4790    ///      "type": "boolean"
4791    ///    },
4792    ///    "DownloadHeaders": {
4793    ///      "type": [
4794    ///        "string",
4795    ///        "null"
4796    ///      ],
4797    ///      "format": "null"
4798    ///    },
4799    ///    "DryRun": {
4800    ///      "type": "boolean"
4801    ///    },
4802    ///    "Dump": {
4803    ///      "type": "string"
4804    ///    },
4805    ///    "ErrorOnNoTransfer": {
4806    ///      "type": "boolean"
4807    ///    },
4808    ///    "ExpectContinueTimeout": {
4809    ///      "type": "number"
4810    ///    },
4811    ///    "FixCase": {
4812    ///      "type": "boolean"
4813    ///    },
4814    ///    "FsCacheExpireDuration": {
4815    ///      "type": "number"
4816    ///    },
4817    ///    "FsCacheExpireInterval": {
4818    ///      "type": "number"
4819    ///    },
4820    ///    "Headers": {
4821    ///      "type": [
4822    ///        "string",
4823    ///        "null"
4824    ///      ],
4825    ///      "format": "null"
4826    ///    },
4827    ///    "HumanReadable": {
4828    ///      "type": "boolean"
4829    ///    },
4830    ///    "IgnoreCaseSync": {
4831    ///      "type": "boolean"
4832    ///    },
4833    ///    "IgnoreChecksum": {
4834    ///      "type": "boolean"
4835    ///    },
4836    ///    "IgnoreErrors": {
4837    ///      "type": "boolean"
4838    ///    },
4839    ///    "IgnoreExisting": {
4840    ///      "type": "boolean"
4841    ///    },
4842    ///    "IgnoreSize": {
4843    ///      "type": "boolean"
4844    ///    },
4845    ///    "IgnoreTimes": {
4846    ///      "type": "boolean"
4847    ///    },
4848    ///    "Immutable": {
4849    ///      "type": "boolean"
4850    ///    },
4851    ///    "Inplace": {
4852    ///      "type": "boolean"
4853    ///    },
4854    ///    "InsecureSkipVerify": {
4855    ///      "type": "boolean"
4856    ///    },
4857    ///    "Interactive": {
4858    ///      "type": "boolean"
4859    ///    },
4860    ///    "KvLockTime": {
4861    ///      "type": "number"
4862    ///    },
4863    ///    "Links": {
4864    ///      "type": "boolean"
4865    ///    },
4866    ///    "LogLevel": {
4867    ///      "type": "string"
4868    ///    },
4869    ///    "LowLevelRetries": {
4870    ///      "type": "number"
4871    ///    },
4872    ///    "MaxBacklog": {
4873    ///      "type": "number"
4874    ///    },
4875    ///    "MaxBufferMemory": {
4876    ///      "type": "number"
4877    ///    },
4878    ///    "MaxDelete": {
4879    ///      "type": "number"
4880    ///    },
4881    ///    "MaxDeleteSize": {
4882    ///      "type": "number"
4883    ///    },
4884    ///    "MaxDepth": {
4885    ///      "type": "number"
4886    ///    },
4887    ///    "MaxDuration": {
4888    ///      "type": "number"
4889    ///    },
4890    ///    "MaxStatsGroups": {
4891    ///      "type": "number"
4892    ///    },
4893    ///    "MaxTransfer": {
4894    ///      "type": "number"
4895    ///    },
4896    ///    "Metadata": {
4897    ///      "type": "boolean"
4898    ///    },
4899    ///    "MetadataMapper": {
4900    ///      "type": [
4901    ///        "string",
4902    ///        "null"
4903    ///      ],
4904    ///      "format": "null"
4905    ///    },
4906    ///    "MetadataSet": {
4907    ///      "type": [
4908    ///        "string",
4909    ///        "null"
4910    ///      ],
4911    ///      "format": "null"
4912    ///    },
4913    ///    "ModifyWindow": {
4914    ///      "type": "number"
4915    ///    },
4916    ///    "MultiThreadChunkSize": {
4917    ///      "type": "number"
4918    ///    },
4919    ///    "MultiThreadCutoff": {
4920    ///      "type": "number"
4921    ///    },
4922    ///    "MultiThreadSet": {
4923    ///      "type": "boolean"
4924    ///    },
4925    ///    "MultiThreadStreams": {
4926    ///      "type": "number"
4927    ///    },
4928    ///    "MultiThreadWriteBufferSize": {
4929    ///      "type": "number"
4930    ///    },
4931    ///    "NoCheckDest": {
4932    ///      "type": "boolean"
4933    ///    },
4934    ///    "NoConsole": {
4935    ///      "type": "boolean"
4936    ///    },
4937    ///    "NoGzip": {
4938    ///      "type": "boolean"
4939    ///    },
4940    ///    "NoTraverse": {
4941    ///      "type": "boolean"
4942    ///    },
4943    ///    "NoUnicodeNormalization": {
4944    ///      "type": "boolean"
4945    ///    },
4946    ///    "NoUpdateDirModTime": {
4947    ///      "type": "boolean"
4948    ///    },
4949    ///    "NoUpdateModTime": {
4950    ///      "type": "boolean"
4951    ///    },
4952    ///    "OrderBy": {
4953    ///      "type": "string"
4954    ///    },
4955    ///    "PartialSuffix": {
4956    ///      "type": "string"
4957    ///    },
4958    ///    "PasswordCommand": {
4959    ///      "type": [
4960    ///        "string",
4961    ///        "null"
4962    ///      ],
4963    ///      "format": "null"
4964    ///    },
4965    ///    "Progress": {
4966    ///      "type": "boolean"
4967    ///    },
4968    ///    "ProgressTerminalTitle": {
4969    ///      "type": "boolean"
4970    ///    },
4971    ///    "RefreshTimes": {
4972    ///      "type": "boolean"
4973    ///    },
4974    ///    "Retries": {
4975    ///      "type": "number"
4976    ///    },
4977    ///    "RetriesInterval": {
4978    ///      "type": "number"
4979    ///    },
4980    ///    "ServerSideAcrossConfigs": {
4981    ///      "type": "boolean"
4982    ///    },
4983    ///    "SizeOnly": {
4984    ///      "type": "boolean"
4985    ///    },
4986    ///    "StatsFileNameLength": {
4987    ///      "type": "number"
4988    ///    },
4989    ///    "StatsLogLevel": {
4990    ///      "type": "string"
4991    ///    },
4992    ///    "StatsOneLine": {
4993    ///      "type": "boolean"
4994    ///    },
4995    ///    "StatsOneLineDate": {
4996    ///      "type": "boolean"
4997    ///    },
4998    ///    "StatsOneLineDateFormat": {
4999    ///      "type": "string"
5000    ///    },
5001    ///    "StreamingUploadCutoff": {
5002    ///      "type": "number"
5003    ///    },
5004    ///    "Suffix": {
5005    ///      "type": "string"
5006    ///    },
5007    ///    "SuffixKeepExtension": {
5008    ///      "type": "boolean"
5009    ///    },
5010    ///    "TPSLimit": {
5011    ///      "type": "number"
5012    ///    },
5013    ///    "TPSLimitBurst": {
5014    ///      "type": "number"
5015    ///    },
5016    ///    "TerminalColorMode": {
5017    ///      "type": "string"
5018    ///    },
5019    ///    "Timeout": {
5020    ///      "type": "number"
5021    ///    },
5022    ///    "TrackRenames": {
5023    ///      "type": "boolean"
5024    ///    },
5025    ///    "TrackRenamesStrategy": {
5026    ///      "type": "string"
5027    ///    },
5028    ///    "TrafficClass": {
5029    ///      "type": "number"
5030    ///    },
5031    ///    "Transfers": {
5032    ///      "type": "number"
5033    ///    },
5034    ///    "UpdateOlder": {
5035    ///      "type": "boolean"
5036    ///    },
5037    ///    "UploadHeaders": {
5038    ///      "type": [
5039    ///        "string",
5040    ///        "null"
5041    ///      ],
5042    ///      "format": "null"
5043    ///    },
5044    ///    "UseJSONLog": {
5045    ///      "type": "boolean"
5046    ///    },
5047    ///    "UseListR": {
5048    ///      "type": "boolean"
5049    ///    },
5050    ///    "UseMmap": {
5051    ///      "type": "boolean"
5052    ///    },
5053    ///    "UseServerModTime": {
5054    ///      "type": "boolean"
5055    ///    },
5056    ///    "UserAgent": {
5057    ///      "type": "string"
5058    ///    }
5059    ///  }
5060    ///}
5061    /// ```
5062    /// </details>
5063    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5064    pub struct OptionsLocalResponseConfig {
5065        #[serde(rename = "AskPassword")]
5066        pub ask_password: bool,
5067        #[serde(rename = "AutoConfirm")]
5068        pub auto_confirm: bool,
5069        #[serde(rename = "BackupDir")]
5070        pub backup_dir: ::std::string::String,
5071        #[serde(rename = "BindAddr")]
5072        pub bind_addr: ::std::string::String,
5073        #[serde(rename = "BufferSize")]
5074        pub buffer_size: f64,
5075        #[serde(rename = "BwLimit")]
5076        pub bw_limit: ::std::string::String,
5077        #[serde(rename = "BwLimitFile")]
5078        pub bw_limit_file: ::std::string::String,
5079        #[serde(rename = "CaCert")]
5080        pub ca_cert: ::std::vec::Vec<::std::string::String>,
5081        #[serde(rename = "CheckFirst")]
5082        pub check_first: bool,
5083        #[serde(rename = "CheckSum")]
5084        pub check_sum: bool,
5085        #[serde(rename = "Checkers")]
5086        pub checkers: f64,
5087        #[serde(rename = "ClientCert")]
5088        pub client_cert: ::std::string::String,
5089        #[serde(rename = "ClientKey")]
5090        pub client_key: ::std::string::String,
5091        #[serde(rename = "CompareDest")]
5092        pub compare_dest: ::std::vec::Vec<::std::string::String>,
5093        #[serde(rename = "ConnectTimeout")]
5094        pub connect_timeout: f64,
5095        #[serde(rename = "Cookie")]
5096        pub cookie: bool,
5097        #[serde(rename = "CopyDest")]
5098        pub copy_dest: ::std::vec::Vec<::std::string::String>,
5099        #[serde(rename = "CutoffMode")]
5100        pub cutoff_mode: ::std::string::String,
5101        #[serde(rename = "DataRateUnit")]
5102        pub data_rate_unit: ::std::string::String,
5103        #[serde(rename = "DefaultTime")]
5104        pub default_time: ::std::string::String,
5105        #[serde(rename = "DeleteMode")]
5106        pub delete_mode: f64,
5107        #[serde(rename = "DisableFeatures")]
5108        pub disable_features: ::std::option::Option<::std::string::String>,
5109        #[serde(rename = "DisableHTTP2")]
5110        pub disable_http2: bool,
5111        #[serde(rename = "DisableHTTPKeepAlives")]
5112        pub disable_http_keep_alives: bool,
5113        #[serde(rename = "DownloadHeaders")]
5114        pub download_headers: ::std::option::Option<::std::string::String>,
5115        #[serde(rename = "DryRun")]
5116        pub dry_run: bool,
5117        #[serde(rename = "Dump")]
5118        pub dump: ::std::string::String,
5119        #[serde(rename = "ErrorOnNoTransfer")]
5120        pub error_on_no_transfer: bool,
5121        #[serde(rename = "ExpectContinueTimeout")]
5122        pub expect_continue_timeout: f64,
5123        #[serde(rename = "FixCase")]
5124        pub fix_case: bool,
5125        #[serde(rename = "FsCacheExpireDuration")]
5126        pub fs_cache_expire_duration: f64,
5127        #[serde(rename = "FsCacheExpireInterval")]
5128        pub fs_cache_expire_interval: f64,
5129        #[serde(rename = "Headers")]
5130        pub headers: ::std::option::Option<::std::string::String>,
5131        #[serde(rename = "HumanReadable")]
5132        pub human_readable: bool,
5133        #[serde(rename = "IgnoreCaseSync")]
5134        pub ignore_case_sync: bool,
5135        #[serde(rename = "IgnoreChecksum")]
5136        pub ignore_checksum: bool,
5137        #[serde(rename = "IgnoreErrors")]
5138        pub ignore_errors: bool,
5139        #[serde(rename = "IgnoreExisting")]
5140        pub ignore_existing: bool,
5141        #[serde(rename = "IgnoreSize")]
5142        pub ignore_size: bool,
5143        #[serde(rename = "IgnoreTimes")]
5144        pub ignore_times: bool,
5145        #[serde(rename = "Immutable")]
5146        pub immutable: bool,
5147        #[serde(rename = "Inplace")]
5148        pub inplace: bool,
5149        #[serde(rename = "InsecureSkipVerify")]
5150        pub insecure_skip_verify: bool,
5151        #[serde(rename = "Interactive")]
5152        pub interactive: bool,
5153        #[serde(rename = "KvLockTime")]
5154        pub kv_lock_time: f64,
5155        #[serde(rename = "Links")]
5156        pub links: bool,
5157        #[serde(rename = "LogLevel")]
5158        pub log_level: ::std::string::String,
5159        #[serde(rename = "LowLevelRetries")]
5160        pub low_level_retries: f64,
5161        #[serde(rename = "MaxBacklog")]
5162        pub max_backlog: f64,
5163        #[serde(rename = "MaxBufferMemory")]
5164        pub max_buffer_memory: f64,
5165        #[serde(rename = "MaxDelete")]
5166        pub max_delete: f64,
5167        #[serde(rename = "MaxDeleteSize")]
5168        pub max_delete_size: f64,
5169        #[serde(rename = "MaxDepth")]
5170        pub max_depth: f64,
5171        #[serde(rename = "MaxDuration")]
5172        pub max_duration: f64,
5173        #[serde(rename = "MaxStatsGroups")]
5174        pub max_stats_groups: f64,
5175        #[serde(rename = "MaxTransfer")]
5176        pub max_transfer: f64,
5177        #[serde(rename = "Metadata")]
5178        pub metadata: bool,
5179        #[serde(rename = "MetadataMapper")]
5180        pub metadata_mapper: ::std::option::Option<::std::string::String>,
5181        #[serde(rename = "MetadataSet")]
5182        pub metadata_set: ::std::option::Option<::std::string::String>,
5183        #[serde(rename = "ModifyWindow")]
5184        pub modify_window: f64,
5185        #[serde(rename = "MultiThreadChunkSize")]
5186        pub multi_thread_chunk_size: f64,
5187        #[serde(rename = "MultiThreadCutoff")]
5188        pub multi_thread_cutoff: f64,
5189        #[serde(rename = "MultiThreadSet")]
5190        pub multi_thread_set: bool,
5191        #[serde(rename = "MultiThreadStreams")]
5192        pub multi_thread_streams: f64,
5193        #[serde(rename = "MultiThreadWriteBufferSize")]
5194        pub multi_thread_write_buffer_size: f64,
5195        #[serde(rename = "NoCheckDest")]
5196        pub no_check_dest: bool,
5197        #[serde(rename = "NoConsole")]
5198        pub no_console: bool,
5199        #[serde(rename = "NoGzip")]
5200        pub no_gzip: bool,
5201        #[serde(rename = "NoTraverse")]
5202        pub no_traverse: bool,
5203        #[serde(rename = "NoUnicodeNormalization")]
5204        pub no_unicode_normalization: bool,
5205        #[serde(rename = "NoUpdateDirModTime")]
5206        pub no_update_dir_mod_time: bool,
5207        #[serde(rename = "NoUpdateModTime")]
5208        pub no_update_mod_time: bool,
5209        #[serde(rename = "OrderBy")]
5210        pub order_by: ::std::string::String,
5211        #[serde(rename = "PartialSuffix")]
5212        pub partial_suffix: ::std::string::String,
5213        #[serde(rename = "PasswordCommand")]
5214        pub password_command: ::std::option::Option<::std::string::String>,
5215        #[serde(rename = "Progress")]
5216        pub progress: bool,
5217        #[serde(rename = "ProgressTerminalTitle")]
5218        pub progress_terminal_title: bool,
5219        #[serde(rename = "RefreshTimes")]
5220        pub refresh_times: bool,
5221        #[serde(rename = "Retries")]
5222        pub retries: f64,
5223        #[serde(rename = "RetriesInterval")]
5224        pub retries_interval: f64,
5225        #[serde(rename = "ServerSideAcrossConfigs")]
5226        pub server_side_across_configs: bool,
5227        #[serde(rename = "SizeOnly")]
5228        pub size_only: bool,
5229        #[serde(rename = "StatsFileNameLength")]
5230        pub stats_file_name_length: f64,
5231        #[serde(rename = "StatsLogLevel")]
5232        pub stats_log_level: ::std::string::String,
5233        #[serde(rename = "StatsOneLine")]
5234        pub stats_one_line: bool,
5235        #[serde(rename = "StatsOneLineDate")]
5236        pub stats_one_line_date: bool,
5237        #[serde(rename = "StatsOneLineDateFormat")]
5238        pub stats_one_line_date_format: ::std::string::String,
5239        #[serde(rename = "StreamingUploadCutoff")]
5240        pub streaming_upload_cutoff: f64,
5241        #[serde(rename = "Suffix")]
5242        pub suffix: ::std::string::String,
5243        #[serde(rename = "SuffixKeepExtension")]
5244        pub suffix_keep_extension: bool,
5245        #[serde(rename = "TerminalColorMode")]
5246        pub terminal_color_mode: ::std::string::String,
5247        #[serde(rename = "Timeout")]
5248        pub timeout: f64,
5249        #[serde(rename = "TPSLimit")]
5250        pub tps_limit: f64,
5251        #[serde(rename = "TPSLimitBurst")]
5252        pub tps_limit_burst: f64,
5253        #[serde(rename = "TrackRenames")]
5254        pub track_renames: bool,
5255        #[serde(rename = "TrackRenamesStrategy")]
5256        pub track_renames_strategy: ::std::string::String,
5257        #[serde(rename = "TrafficClass")]
5258        pub traffic_class: f64,
5259        #[serde(rename = "Transfers")]
5260        pub transfers: f64,
5261        #[serde(rename = "UpdateOlder")]
5262        pub update_older: bool,
5263        #[serde(rename = "UploadHeaders")]
5264        pub upload_headers: ::std::option::Option<::std::string::String>,
5265        #[serde(rename = "UseJSONLog")]
5266        pub use_json_log: bool,
5267        #[serde(rename = "UseListR")]
5268        pub use_list_r: bool,
5269        #[serde(rename = "UseMmap")]
5270        pub use_mmap: bool,
5271        #[serde(rename = "UseServerModTime")]
5272        pub use_server_mod_time: bool,
5273        #[serde(rename = "UserAgent")]
5274        pub user_agent: ::std::string::String,
5275    }
5276
5277    impl ::std::convert::From<&OptionsLocalResponseConfig> for OptionsLocalResponseConfig {
5278        fn from(value: &OptionsLocalResponseConfig) -> Self {
5279            value.clone()
5280        }
5281    }
5282
5283    ///`OptionsLocalResponseFilter`
5284    ///
5285    /// <details><summary>JSON schema</summary>
5286    ///
5287    /// ```json
5288    ///{
5289    ///  "type": "object",
5290    ///  "required": [
5291    ///    "DeleteExcluded",
5292    ///    "ExcludeFile",
5293    ///    "ExcludeFrom",
5294    ///    "ExcludeRule",
5295    ///    "FilesFrom",
5296    ///    "FilesFromRaw",
5297    ///    "FilterFrom",
5298    ///    "FilterRule",
5299    ///    "HashFilter",
5300    ///    "IgnoreCase",
5301    ///    "IncludeFrom",
5302    ///    "IncludeRule",
5303    ///    "MaxAge",
5304    ///    "MaxSize",
5305    ///    "MetaRules",
5306    ///    "MinAge",
5307    ///    "MinSize"
5308    ///  ],
5309    ///  "properties": {
5310    ///    "DeleteExcluded": {
5311    ///      "type": "boolean"
5312    ///    },
5313    ///    "ExcludeFile": {
5314    ///      "type": "array",
5315    ///      "items": {
5316    ///        "type": "string"
5317    ///      }
5318    ///    },
5319    ///    "ExcludeFrom": {
5320    ///      "type": "array",
5321    ///      "items": {
5322    ///        "type": "string"
5323    ///      }
5324    ///    },
5325    ///    "ExcludeRule": {
5326    ///      "type": "array",
5327    ///      "items": {
5328    ///        "type": "string"
5329    ///      }
5330    ///    },
5331    ///    "FilesFrom": {
5332    ///      "type": "array",
5333    ///      "items": {
5334    ///        "type": "string"
5335    ///      }
5336    ///    },
5337    ///    "FilesFromRaw": {
5338    ///      "type": "array",
5339    ///      "items": {
5340    ///        "type": "string"
5341    ///      }
5342    ///    },
5343    ///    "FilterFrom": {
5344    ///      "type": "array",
5345    ///      "items": {
5346    ///        "type": "string"
5347    ///      }
5348    ///    },
5349    ///    "FilterRule": {
5350    ///      "type": "array",
5351    ///      "items": {
5352    ///        "type": "string"
5353    ///      }
5354    ///    },
5355    ///    "HashFilter": {
5356    ///      "type": "string"
5357    ///    },
5358    ///    "IgnoreCase": {
5359    ///      "type": "boolean"
5360    ///    },
5361    ///    "IncludeFrom": {
5362    ///      "type": "array",
5363    ///      "items": {
5364    ///        "type": "string"
5365    ///      }
5366    ///    },
5367    ///    "IncludeRule": {
5368    ///      "type": "array",
5369    ///      "items": {
5370    ///        "type": "string"
5371    ///      }
5372    ///    },
5373    ///    "MaxAge": {
5374    ///      "type": "number"
5375    ///    },
5376    ///    "MaxSize": {
5377    ///      "type": "number"
5378    ///    },
5379    ///    "MetaRules": {
5380    ///      "type": "object",
5381    ///      "required": [
5382    ///        "ExcludeFrom",
5383    ///        "ExcludeRule",
5384    ///        "FilterFrom",
5385    ///        "FilterRule",
5386    ///        "IncludeFrom",
5387    ///        "IncludeRule"
5388    ///      ],
5389    ///      "properties": {
5390    ///        "ExcludeFrom": {
5391    ///          "type": "array",
5392    ///          "items": {
5393    ///            "type": "string"
5394    ///          }
5395    ///        },
5396    ///        "ExcludeRule": {
5397    ///          "type": "array",
5398    ///          "items": {
5399    ///            "type": "string"
5400    ///          }
5401    ///        },
5402    ///        "FilterFrom": {
5403    ///          "type": "array",
5404    ///          "items": {
5405    ///            "type": "string"
5406    ///          }
5407    ///        },
5408    ///        "FilterRule": {
5409    ///          "type": "array",
5410    ///          "items": {
5411    ///            "type": "string"
5412    ///          }
5413    ///        },
5414    ///        "IncludeFrom": {
5415    ///          "type": "array",
5416    ///          "items": {
5417    ///            "type": "string"
5418    ///          }
5419    ///        },
5420    ///        "IncludeRule": {
5421    ///          "type": "array",
5422    ///          "items": {
5423    ///            "type": "string"
5424    ///          }
5425    ///        }
5426    ///      }
5427    ///    },
5428    ///    "MinAge": {
5429    ///      "type": "number"
5430    ///    },
5431    ///    "MinSize": {
5432    ///      "type": "number"
5433    ///    }
5434    ///  }
5435    ///}
5436    /// ```
5437    /// </details>
5438    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5439    pub struct OptionsLocalResponseFilter {
5440        #[serde(rename = "DeleteExcluded")]
5441        pub delete_excluded: bool,
5442        #[serde(rename = "ExcludeFile")]
5443        pub exclude_file: ::std::vec::Vec<::std::string::String>,
5444        #[serde(rename = "ExcludeFrom")]
5445        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5446        #[serde(rename = "ExcludeRule")]
5447        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5448        #[serde(rename = "FilesFrom")]
5449        pub files_from: ::std::vec::Vec<::std::string::String>,
5450        #[serde(rename = "FilesFromRaw")]
5451        pub files_from_raw: ::std::vec::Vec<::std::string::String>,
5452        #[serde(rename = "FilterFrom")]
5453        pub filter_from: ::std::vec::Vec<::std::string::String>,
5454        #[serde(rename = "FilterRule")]
5455        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5456        #[serde(rename = "HashFilter")]
5457        pub hash_filter: ::std::string::String,
5458        #[serde(rename = "IgnoreCase")]
5459        pub ignore_case: bool,
5460        #[serde(rename = "IncludeFrom")]
5461        pub include_from: ::std::vec::Vec<::std::string::String>,
5462        #[serde(rename = "IncludeRule")]
5463        pub include_rule: ::std::vec::Vec<::std::string::String>,
5464        #[serde(rename = "MaxAge")]
5465        pub max_age: f64,
5466        #[serde(rename = "MaxSize")]
5467        pub max_size: f64,
5468        #[serde(rename = "MetaRules")]
5469        pub meta_rules: OptionsLocalResponseFilterMetaRules,
5470        #[serde(rename = "MinAge")]
5471        pub min_age: f64,
5472        #[serde(rename = "MinSize")]
5473        pub min_size: f64,
5474    }
5475
5476    impl ::std::convert::From<&OptionsLocalResponseFilter> for OptionsLocalResponseFilter {
5477        fn from(value: &OptionsLocalResponseFilter) -> Self {
5478            value.clone()
5479        }
5480    }
5481
5482    ///`OptionsLocalResponseFilterMetaRules`
5483    ///
5484    /// <details><summary>JSON schema</summary>
5485    ///
5486    /// ```json
5487    ///{
5488    ///  "type": "object",
5489    ///  "required": [
5490    ///    "ExcludeFrom",
5491    ///    "ExcludeRule",
5492    ///    "FilterFrom",
5493    ///    "FilterRule",
5494    ///    "IncludeFrom",
5495    ///    "IncludeRule"
5496    ///  ],
5497    ///  "properties": {
5498    ///    "ExcludeFrom": {
5499    ///      "type": "array",
5500    ///      "items": {
5501    ///        "type": "string"
5502    ///      }
5503    ///    },
5504    ///    "ExcludeRule": {
5505    ///      "type": "array",
5506    ///      "items": {
5507    ///        "type": "string"
5508    ///      }
5509    ///    },
5510    ///    "FilterFrom": {
5511    ///      "type": "array",
5512    ///      "items": {
5513    ///        "type": "string"
5514    ///      }
5515    ///    },
5516    ///    "FilterRule": {
5517    ///      "type": "array",
5518    ///      "items": {
5519    ///        "type": "string"
5520    ///      }
5521    ///    },
5522    ///    "IncludeFrom": {
5523    ///      "type": "array",
5524    ///      "items": {
5525    ///        "type": "string"
5526    ///      }
5527    ///    },
5528    ///    "IncludeRule": {
5529    ///      "type": "array",
5530    ///      "items": {
5531    ///        "type": "string"
5532    ///      }
5533    ///    }
5534    ///  }
5535    ///}
5536    /// ```
5537    /// </details>
5538    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5539    pub struct OptionsLocalResponseFilterMetaRules {
5540        #[serde(rename = "ExcludeFrom")]
5541        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5542        #[serde(rename = "ExcludeRule")]
5543        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5544        #[serde(rename = "FilterFrom")]
5545        pub filter_from: ::std::vec::Vec<::std::string::String>,
5546        #[serde(rename = "FilterRule")]
5547        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5548        #[serde(rename = "IncludeFrom")]
5549        pub include_from: ::std::vec::Vec<::std::string::String>,
5550        #[serde(rename = "IncludeRule")]
5551        pub include_rule: ::std::vec::Vec<::std::string::String>,
5552    }
5553
5554    impl ::std::convert::From<&OptionsLocalResponseFilterMetaRules>
5555        for OptionsLocalResponseFilterMetaRules
5556    {
5557        fn from(value: &OptionsLocalResponseFilterMetaRules) -> Self {
5558            value.clone()
5559        }
5560    }
5561
5562    ///`OptionsSetDlnaValue`
5563    ///
5564    /// <details><summary>JSON schema</summary>
5565    ///
5566    /// ```json
5567    ///{
5568    ///  "oneOf": [
5569    ///    {
5570    ///      "type": "string"
5571    ///    },
5572    ///    {
5573    ///      "type": "number"
5574    ///    },
5575    ///    {
5576    ///      "type": "integer"
5577    ///    },
5578    ///    {
5579    ///      "type": "boolean"
5580    ///    },
5581    ///    {
5582    ///      "type": "array",
5583    ///      "items": {}
5584    ///    },
5585    ///    {
5586    ///      "type": "object",
5587    ///      "additionalProperties": {}
5588    ///    }
5589    ///  ]
5590    ///}
5591    /// ```
5592    /// </details>
5593    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5594    #[serde(untagged)]
5595    pub enum OptionsSetDlnaValue {
5596        Variant0(::std::string::String),
5597        Variant1(f64),
5598        Variant2(i64),
5599        Variant3(bool),
5600        Variant4(::std::vec::Vec<::serde_json::Value>),
5601        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5602    }
5603
5604    impl ::std::convert::From<&Self> for OptionsSetDlnaValue {
5605        fn from(value: &OptionsSetDlnaValue) -> Self {
5606            value.clone()
5607        }
5608    }
5609
5610    impl ::std::convert::From<f64> for OptionsSetDlnaValue {
5611        fn from(value: f64) -> Self {
5612            Self::Variant1(value)
5613        }
5614    }
5615
5616    impl ::std::convert::From<i64> for OptionsSetDlnaValue {
5617        fn from(value: i64) -> Self {
5618            Self::Variant2(value)
5619        }
5620    }
5621
5622    impl ::std::convert::From<bool> for OptionsSetDlnaValue {
5623        fn from(value: bool) -> Self {
5624            Self::Variant3(value)
5625        }
5626    }
5627
5628    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetDlnaValue {
5629        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5630            Self::Variant4(value)
5631        }
5632    }
5633
5634    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5635        for OptionsSetDlnaValue
5636    {
5637        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5638            Self::Variant5(value)
5639        }
5640    }
5641
5642    ///`OptionsSetFilterValue`
5643    ///
5644    /// <details><summary>JSON schema</summary>
5645    ///
5646    /// ```json
5647    ///{
5648    ///  "oneOf": [
5649    ///    {
5650    ///      "type": "string"
5651    ///    },
5652    ///    {
5653    ///      "type": "number"
5654    ///    },
5655    ///    {
5656    ///      "type": "integer"
5657    ///    },
5658    ///    {
5659    ///      "type": "boolean"
5660    ///    },
5661    ///    {
5662    ///      "type": "array",
5663    ///      "items": {}
5664    ///    },
5665    ///    {
5666    ///      "type": "object",
5667    ///      "additionalProperties": {}
5668    ///    }
5669    ///  ]
5670    ///}
5671    /// ```
5672    /// </details>
5673    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5674    #[serde(untagged)]
5675    pub enum OptionsSetFilterValue {
5676        Variant0(::std::string::String),
5677        Variant1(f64),
5678        Variant2(i64),
5679        Variant3(bool),
5680        Variant4(::std::vec::Vec<::serde_json::Value>),
5681        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5682    }
5683
5684    impl ::std::convert::From<&Self> for OptionsSetFilterValue {
5685        fn from(value: &OptionsSetFilterValue) -> Self {
5686            value.clone()
5687        }
5688    }
5689
5690    impl ::std::convert::From<f64> for OptionsSetFilterValue {
5691        fn from(value: f64) -> Self {
5692            Self::Variant1(value)
5693        }
5694    }
5695
5696    impl ::std::convert::From<i64> for OptionsSetFilterValue {
5697        fn from(value: i64) -> Self {
5698            Self::Variant2(value)
5699        }
5700    }
5701
5702    impl ::std::convert::From<bool> for OptionsSetFilterValue {
5703        fn from(value: bool) -> Self {
5704            Self::Variant3(value)
5705        }
5706    }
5707
5708    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFilterValue {
5709        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5710            Self::Variant4(value)
5711        }
5712    }
5713
5714    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5715        for OptionsSetFilterValue
5716    {
5717        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5718            Self::Variant5(value)
5719        }
5720    }
5721
5722    ///`OptionsSetFtpValue`
5723    ///
5724    /// <details><summary>JSON schema</summary>
5725    ///
5726    /// ```json
5727    ///{
5728    ///  "oneOf": [
5729    ///    {
5730    ///      "type": "string"
5731    ///    },
5732    ///    {
5733    ///      "type": "number"
5734    ///    },
5735    ///    {
5736    ///      "type": "integer"
5737    ///    },
5738    ///    {
5739    ///      "type": "boolean"
5740    ///    },
5741    ///    {
5742    ///      "type": "array",
5743    ///      "items": {}
5744    ///    },
5745    ///    {
5746    ///      "type": "object",
5747    ///      "additionalProperties": {}
5748    ///    }
5749    ///  ]
5750    ///}
5751    /// ```
5752    /// </details>
5753    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5754    #[serde(untagged)]
5755    pub enum OptionsSetFtpValue {
5756        Variant0(::std::string::String),
5757        Variant1(f64),
5758        Variant2(i64),
5759        Variant3(bool),
5760        Variant4(::std::vec::Vec<::serde_json::Value>),
5761        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5762    }
5763
5764    impl ::std::convert::From<&Self> for OptionsSetFtpValue {
5765        fn from(value: &OptionsSetFtpValue) -> Self {
5766            value.clone()
5767        }
5768    }
5769
5770    impl ::std::convert::From<f64> for OptionsSetFtpValue {
5771        fn from(value: f64) -> Self {
5772            Self::Variant1(value)
5773        }
5774    }
5775
5776    impl ::std::convert::From<i64> for OptionsSetFtpValue {
5777        fn from(value: i64) -> Self {
5778            Self::Variant2(value)
5779        }
5780    }
5781
5782    impl ::std::convert::From<bool> for OptionsSetFtpValue {
5783        fn from(value: bool) -> Self {
5784            Self::Variant3(value)
5785        }
5786    }
5787
5788    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFtpValue {
5789        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5790            Self::Variant4(value)
5791        }
5792    }
5793
5794    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5795        for OptionsSetFtpValue
5796    {
5797        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5798            Self::Variant5(value)
5799        }
5800    }
5801
5802    ///`OptionsSetHttpValue`
5803    ///
5804    /// <details><summary>JSON schema</summary>
5805    ///
5806    /// ```json
5807    ///{
5808    ///  "oneOf": [
5809    ///    {
5810    ///      "type": "string"
5811    ///    },
5812    ///    {
5813    ///      "type": "number"
5814    ///    },
5815    ///    {
5816    ///      "type": "integer"
5817    ///    },
5818    ///    {
5819    ///      "type": "boolean"
5820    ///    },
5821    ///    {
5822    ///      "type": "array",
5823    ///      "items": {}
5824    ///    },
5825    ///    {
5826    ///      "type": "object",
5827    ///      "additionalProperties": {}
5828    ///    }
5829    ///  ]
5830    ///}
5831    /// ```
5832    /// </details>
5833    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5834    #[serde(untagged)]
5835    pub enum OptionsSetHttpValue {
5836        Variant0(::std::string::String),
5837        Variant1(f64),
5838        Variant2(i64),
5839        Variant3(bool),
5840        Variant4(::std::vec::Vec<::serde_json::Value>),
5841        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5842    }
5843
5844    impl ::std::convert::From<&Self> for OptionsSetHttpValue {
5845        fn from(value: &OptionsSetHttpValue) -> Self {
5846            value.clone()
5847        }
5848    }
5849
5850    impl ::std::convert::From<f64> for OptionsSetHttpValue {
5851        fn from(value: f64) -> Self {
5852            Self::Variant1(value)
5853        }
5854    }
5855
5856    impl ::std::convert::From<i64> for OptionsSetHttpValue {
5857        fn from(value: i64) -> Self {
5858            Self::Variant2(value)
5859        }
5860    }
5861
5862    impl ::std::convert::From<bool> for OptionsSetHttpValue {
5863        fn from(value: bool) -> Self {
5864            Self::Variant3(value)
5865        }
5866    }
5867
5868    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetHttpValue {
5869        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5870            Self::Variant4(value)
5871        }
5872    }
5873
5874    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5875        for OptionsSetHttpValue
5876    {
5877        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5878            Self::Variant5(value)
5879        }
5880    }
5881
5882    ///`OptionsSetLogValue`
5883    ///
5884    /// <details><summary>JSON schema</summary>
5885    ///
5886    /// ```json
5887    ///{
5888    ///  "oneOf": [
5889    ///    {
5890    ///      "type": "string"
5891    ///    },
5892    ///    {
5893    ///      "type": "number"
5894    ///    },
5895    ///    {
5896    ///      "type": "integer"
5897    ///    },
5898    ///    {
5899    ///      "type": "boolean"
5900    ///    },
5901    ///    {
5902    ///      "type": "array",
5903    ///      "items": {}
5904    ///    },
5905    ///    {
5906    ///      "type": "object",
5907    ///      "additionalProperties": {}
5908    ///    }
5909    ///  ]
5910    ///}
5911    /// ```
5912    /// </details>
5913    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5914    #[serde(untagged)]
5915    pub enum OptionsSetLogValue {
5916        Variant0(::std::string::String),
5917        Variant1(f64),
5918        Variant2(i64),
5919        Variant3(bool),
5920        Variant4(::std::vec::Vec<::serde_json::Value>),
5921        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5922    }
5923
5924    impl ::std::convert::From<&Self> for OptionsSetLogValue {
5925        fn from(value: &OptionsSetLogValue) -> Self {
5926            value.clone()
5927        }
5928    }
5929
5930    impl ::std::convert::From<f64> for OptionsSetLogValue {
5931        fn from(value: f64) -> Self {
5932            Self::Variant1(value)
5933        }
5934    }
5935
5936    impl ::std::convert::From<i64> for OptionsSetLogValue {
5937        fn from(value: i64) -> Self {
5938            Self::Variant2(value)
5939        }
5940    }
5941
5942    impl ::std::convert::From<bool> for OptionsSetLogValue {
5943        fn from(value: bool) -> Self {
5944            Self::Variant3(value)
5945        }
5946    }
5947
5948    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetLogValue {
5949        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5950            Self::Variant4(value)
5951        }
5952    }
5953
5954    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5955        for OptionsSetLogValue
5956    {
5957        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5958            Self::Variant5(value)
5959        }
5960    }
5961
5962    ///`OptionsSetMainValue`
5963    ///
5964    /// <details><summary>JSON schema</summary>
5965    ///
5966    /// ```json
5967    ///{
5968    ///  "oneOf": [
5969    ///    {
5970    ///      "type": "string"
5971    ///    },
5972    ///    {
5973    ///      "type": "number"
5974    ///    },
5975    ///    {
5976    ///      "type": "integer"
5977    ///    },
5978    ///    {
5979    ///      "type": "boolean"
5980    ///    },
5981    ///    {
5982    ///      "type": "array",
5983    ///      "items": {}
5984    ///    },
5985    ///    {
5986    ///      "type": "object",
5987    ///      "additionalProperties": {}
5988    ///    }
5989    ///  ]
5990    ///}
5991    /// ```
5992    /// </details>
5993    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5994    #[serde(untagged)]
5995    pub enum OptionsSetMainValue {
5996        Variant0(::std::string::String),
5997        Variant1(f64),
5998        Variant2(i64),
5999        Variant3(bool),
6000        Variant4(::std::vec::Vec<::serde_json::Value>),
6001        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6002    }
6003
6004    impl ::std::convert::From<&Self> for OptionsSetMainValue {
6005        fn from(value: &OptionsSetMainValue) -> Self {
6006            value.clone()
6007        }
6008    }
6009
6010    impl ::std::convert::From<f64> for OptionsSetMainValue {
6011        fn from(value: f64) -> Self {
6012            Self::Variant1(value)
6013        }
6014    }
6015
6016    impl ::std::convert::From<i64> for OptionsSetMainValue {
6017        fn from(value: i64) -> Self {
6018            Self::Variant2(value)
6019        }
6020    }
6021
6022    impl ::std::convert::From<bool> for OptionsSetMainValue {
6023        fn from(value: bool) -> Self {
6024            Self::Variant3(value)
6025        }
6026    }
6027
6028    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMainValue {
6029        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6030            Self::Variant4(value)
6031        }
6032    }
6033
6034    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6035        for OptionsSetMainValue
6036    {
6037        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6038            Self::Variant5(value)
6039        }
6040    }
6041
6042    ///`OptionsSetMountValue`
6043    ///
6044    /// <details><summary>JSON schema</summary>
6045    ///
6046    /// ```json
6047    ///{
6048    ///  "oneOf": [
6049    ///    {
6050    ///      "type": "string"
6051    ///    },
6052    ///    {
6053    ///      "type": "number"
6054    ///    },
6055    ///    {
6056    ///      "type": "integer"
6057    ///    },
6058    ///    {
6059    ///      "type": "boolean"
6060    ///    },
6061    ///    {
6062    ///      "type": "array",
6063    ///      "items": {}
6064    ///    },
6065    ///    {
6066    ///      "type": "object",
6067    ///      "additionalProperties": {}
6068    ///    }
6069    ///  ]
6070    ///}
6071    /// ```
6072    /// </details>
6073    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6074    #[serde(untagged)]
6075    pub enum OptionsSetMountValue {
6076        Variant0(::std::string::String),
6077        Variant1(f64),
6078        Variant2(i64),
6079        Variant3(bool),
6080        Variant4(::std::vec::Vec<::serde_json::Value>),
6081        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6082    }
6083
6084    impl ::std::convert::From<&Self> for OptionsSetMountValue {
6085        fn from(value: &OptionsSetMountValue) -> Self {
6086            value.clone()
6087        }
6088    }
6089
6090    impl ::std::convert::From<f64> for OptionsSetMountValue {
6091        fn from(value: f64) -> Self {
6092            Self::Variant1(value)
6093        }
6094    }
6095
6096    impl ::std::convert::From<i64> for OptionsSetMountValue {
6097        fn from(value: i64) -> Self {
6098            Self::Variant2(value)
6099        }
6100    }
6101
6102    impl ::std::convert::From<bool> for OptionsSetMountValue {
6103        fn from(value: bool) -> Self {
6104            Self::Variant3(value)
6105        }
6106    }
6107
6108    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMountValue {
6109        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6110            Self::Variant4(value)
6111        }
6112    }
6113
6114    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6115        for OptionsSetMountValue
6116    {
6117        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6118            Self::Variant5(value)
6119        }
6120    }
6121
6122    ///`OptionsSetNfsValue`
6123    ///
6124    /// <details><summary>JSON schema</summary>
6125    ///
6126    /// ```json
6127    ///{
6128    ///  "oneOf": [
6129    ///    {
6130    ///      "type": "string"
6131    ///    },
6132    ///    {
6133    ///      "type": "number"
6134    ///    },
6135    ///    {
6136    ///      "type": "integer"
6137    ///    },
6138    ///    {
6139    ///      "type": "boolean"
6140    ///    },
6141    ///    {
6142    ///      "type": "array",
6143    ///      "items": {}
6144    ///    },
6145    ///    {
6146    ///      "type": "object",
6147    ///      "additionalProperties": {}
6148    ///    }
6149    ///  ]
6150    ///}
6151    /// ```
6152    /// </details>
6153    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6154    #[serde(untagged)]
6155    pub enum OptionsSetNfsValue {
6156        Variant0(::std::string::String),
6157        Variant1(f64),
6158        Variant2(i64),
6159        Variant3(bool),
6160        Variant4(::std::vec::Vec<::serde_json::Value>),
6161        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6162    }
6163
6164    impl ::std::convert::From<&Self> for OptionsSetNfsValue {
6165        fn from(value: &OptionsSetNfsValue) -> Self {
6166            value.clone()
6167        }
6168    }
6169
6170    impl ::std::convert::From<f64> for OptionsSetNfsValue {
6171        fn from(value: f64) -> Self {
6172            Self::Variant1(value)
6173        }
6174    }
6175
6176    impl ::std::convert::From<i64> for OptionsSetNfsValue {
6177        fn from(value: i64) -> Self {
6178            Self::Variant2(value)
6179        }
6180    }
6181
6182    impl ::std::convert::From<bool> for OptionsSetNfsValue {
6183        fn from(value: bool) -> Self {
6184            Self::Variant3(value)
6185        }
6186    }
6187
6188    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetNfsValue {
6189        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6190            Self::Variant4(value)
6191        }
6192    }
6193
6194    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6195        for OptionsSetNfsValue
6196    {
6197        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6198            Self::Variant5(value)
6199        }
6200    }
6201
6202    ///`OptionsSetProxyValue`
6203    ///
6204    /// <details><summary>JSON schema</summary>
6205    ///
6206    /// ```json
6207    ///{
6208    ///  "oneOf": [
6209    ///    {
6210    ///      "type": "string"
6211    ///    },
6212    ///    {
6213    ///      "type": "number"
6214    ///    },
6215    ///    {
6216    ///      "type": "integer"
6217    ///    },
6218    ///    {
6219    ///      "type": "boolean"
6220    ///    },
6221    ///    {
6222    ///      "type": "array",
6223    ///      "items": {}
6224    ///    },
6225    ///    {
6226    ///      "type": "object",
6227    ///      "additionalProperties": {}
6228    ///    }
6229    ///  ]
6230    ///}
6231    /// ```
6232    /// </details>
6233    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6234    #[serde(untagged)]
6235    pub enum OptionsSetProxyValue {
6236        Variant0(::std::string::String),
6237        Variant1(f64),
6238        Variant2(i64),
6239        Variant3(bool),
6240        Variant4(::std::vec::Vec<::serde_json::Value>),
6241        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6242    }
6243
6244    impl ::std::convert::From<&Self> for OptionsSetProxyValue {
6245        fn from(value: &OptionsSetProxyValue) -> Self {
6246            value.clone()
6247        }
6248    }
6249
6250    impl ::std::convert::From<f64> for OptionsSetProxyValue {
6251        fn from(value: f64) -> Self {
6252            Self::Variant1(value)
6253        }
6254    }
6255
6256    impl ::std::convert::From<i64> for OptionsSetProxyValue {
6257        fn from(value: i64) -> Self {
6258            Self::Variant2(value)
6259        }
6260    }
6261
6262    impl ::std::convert::From<bool> for OptionsSetProxyValue {
6263        fn from(value: bool) -> Self {
6264            Self::Variant3(value)
6265        }
6266    }
6267
6268    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetProxyValue {
6269        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6270            Self::Variant4(value)
6271        }
6272    }
6273
6274    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6275        for OptionsSetProxyValue
6276    {
6277        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6278            Self::Variant5(value)
6279        }
6280    }
6281
6282    ///`OptionsSetRcValue`
6283    ///
6284    /// <details><summary>JSON schema</summary>
6285    ///
6286    /// ```json
6287    ///{
6288    ///  "oneOf": [
6289    ///    {
6290    ///      "type": "string"
6291    ///    },
6292    ///    {
6293    ///      "type": "number"
6294    ///    },
6295    ///    {
6296    ///      "type": "integer"
6297    ///    },
6298    ///    {
6299    ///      "type": "boolean"
6300    ///    },
6301    ///    {
6302    ///      "type": "array",
6303    ///      "items": {}
6304    ///    },
6305    ///    {
6306    ///      "type": "object",
6307    ///      "additionalProperties": {}
6308    ///    }
6309    ///  ]
6310    ///}
6311    /// ```
6312    /// </details>
6313    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6314    #[serde(untagged)]
6315    pub enum OptionsSetRcValue {
6316        Variant0(::std::string::String),
6317        Variant1(f64),
6318        Variant2(i64),
6319        Variant3(bool),
6320        Variant4(::std::vec::Vec<::serde_json::Value>),
6321        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6322    }
6323
6324    impl ::std::convert::From<&Self> for OptionsSetRcValue {
6325        fn from(value: &OptionsSetRcValue) -> Self {
6326            value.clone()
6327        }
6328    }
6329
6330    impl ::std::convert::From<f64> for OptionsSetRcValue {
6331        fn from(value: f64) -> Self {
6332            Self::Variant1(value)
6333        }
6334    }
6335
6336    impl ::std::convert::From<i64> for OptionsSetRcValue {
6337        fn from(value: i64) -> Self {
6338            Self::Variant2(value)
6339        }
6340    }
6341
6342    impl ::std::convert::From<bool> for OptionsSetRcValue {
6343        fn from(value: bool) -> Self {
6344            Self::Variant3(value)
6345        }
6346    }
6347
6348    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetRcValue {
6349        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6350            Self::Variant4(value)
6351        }
6352    }
6353
6354    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6355        for OptionsSetRcValue
6356    {
6357        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6358            Self::Variant5(value)
6359        }
6360    }
6361
6362    ///`OptionsSetResticValue`
6363    ///
6364    /// <details><summary>JSON schema</summary>
6365    ///
6366    /// ```json
6367    ///{
6368    ///  "oneOf": [
6369    ///    {
6370    ///      "type": "string"
6371    ///    },
6372    ///    {
6373    ///      "type": "number"
6374    ///    },
6375    ///    {
6376    ///      "type": "integer"
6377    ///    },
6378    ///    {
6379    ///      "type": "boolean"
6380    ///    },
6381    ///    {
6382    ///      "type": "array",
6383    ///      "items": {}
6384    ///    },
6385    ///    {
6386    ///      "type": "object",
6387    ///      "additionalProperties": {}
6388    ///    }
6389    ///  ]
6390    ///}
6391    /// ```
6392    /// </details>
6393    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6394    #[serde(untagged)]
6395    pub enum OptionsSetResticValue {
6396        Variant0(::std::string::String),
6397        Variant1(f64),
6398        Variant2(i64),
6399        Variant3(bool),
6400        Variant4(::std::vec::Vec<::serde_json::Value>),
6401        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6402    }
6403
6404    impl ::std::convert::From<&Self> for OptionsSetResticValue {
6405        fn from(value: &OptionsSetResticValue) -> Self {
6406            value.clone()
6407        }
6408    }
6409
6410    impl ::std::convert::From<f64> for OptionsSetResticValue {
6411        fn from(value: f64) -> Self {
6412            Self::Variant1(value)
6413        }
6414    }
6415
6416    impl ::std::convert::From<i64> for OptionsSetResticValue {
6417        fn from(value: i64) -> Self {
6418            Self::Variant2(value)
6419        }
6420    }
6421
6422    impl ::std::convert::From<bool> for OptionsSetResticValue {
6423        fn from(value: bool) -> Self {
6424            Self::Variant3(value)
6425        }
6426    }
6427
6428    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetResticValue {
6429        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6430            Self::Variant4(value)
6431        }
6432    }
6433
6434    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6435        for OptionsSetResticValue
6436    {
6437        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6438            Self::Variant5(value)
6439        }
6440    }
6441
6442    ///`OptionsSetS3Value`
6443    ///
6444    /// <details><summary>JSON schema</summary>
6445    ///
6446    /// ```json
6447    ///{
6448    ///  "oneOf": [
6449    ///    {
6450    ///      "type": "string"
6451    ///    },
6452    ///    {
6453    ///      "type": "number"
6454    ///    },
6455    ///    {
6456    ///      "type": "integer"
6457    ///    },
6458    ///    {
6459    ///      "type": "boolean"
6460    ///    },
6461    ///    {
6462    ///      "type": "array",
6463    ///      "items": {}
6464    ///    },
6465    ///    {
6466    ///      "type": "object",
6467    ///      "additionalProperties": {}
6468    ///    }
6469    ///  ]
6470    ///}
6471    /// ```
6472    /// </details>
6473    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6474    #[serde(untagged)]
6475    pub enum OptionsSetS3Value {
6476        Variant0(::std::string::String),
6477        Variant1(f64),
6478        Variant2(i64),
6479        Variant3(bool),
6480        Variant4(::std::vec::Vec<::serde_json::Value>),
6481        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6482    }
6483
6484    impl ::std::convert::From<&Self> for OptionsSetS3Value {
6485        fn from(value: &OptionsSetS3Value) -> Self {
6486            value.clone()
6487        }
6488    }
6489
6490    impl ::std::convert::From<f64> for OptionsSetS3Value {
6491        fn from(value: f64) -> Self {
6492            Self::Variant1(value)
6493        }
6494    }
6495
6496    impl ::std::convert::From<i64> for OptionsSetS3Value {
6497        fn from(value: i64) -> Self {
6498            Self::Variant2(value)
6499        }
6500    }
6501
6502    impl ::std::convert::From<bool> for OptionsSetS3Value {
6503        fn from(value: bool) -> Self {
6504            Self::Variant3(value)
6505        }
6506    }
6507
6508    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetS3Value {
6509        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6510            Self::Variant4(value)
6511        }
6512    }
6513
6514    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6515        for OptionsSetS3Value
6516    {
6517        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6518            Self::Variant5(value)
6519        }
6520    }
6521
6522    ///`OptionsSetSftpValue`
6523    ///
6524    /// <details><summary>JSON schema</summary>
6525    ///
6526    /// ```json
6527    ///{
6528    ///  "oneOf": [
6529    ///    {
6530    ///      "type": "string"
6531    ///    },
6532    ///    {
6533    ///      "type": "number"
6534    ///    },
6535    ///    {
6536    ///      "type": "integer"
6537    ///    },
6538    ///    {
6539    ///      "type": "boolean"
6540    ///    },
6541    ///    {
6542    ///      "type": "array",
6543    ///      "items": {}
6544    ///    },
6545    ///    {
6546    ///      "type": "object",
6547    ///      "additionalProperties": {}
6548    ///    }
6549    ///  ]
6550    ///}
6551    /// ```
6552    /// </details>
6553    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6554    #[serde(untagged)]
6555    pub enum OptionsSetSftpValue {
6556        Variant0(::std::string::String),
6557        Variant1(f64),
6558        Variant2(i64),
6559        Variant3(bool),
6560        Variant4(::std::vec::Vec<::serde_json::Value>),
6561        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6562    }
6563
6564    impl ::std::convert::From<&Self> for OptionsSetSftpValue {
6565        fn from(value: &OptionsSetSftpValue) -> Self {
6566            value.clone()
6567        }
6568    }
6569
6570    impl ::std::convert::From<f64> for OptionsSetSftpValue {
6571        fn from(value: f64) -> Self {
6572            Self::Variant1(value)
6573        }
6574    }
6575
6576    impl ::std::convert::From<i64> for OptionsSetSftpValue {
6577        fn from(value: i64) -> Self {
6578            Self::Variant2(value)
6579        }
6580    }
6581
6582    impl ::std::convert::From<bool> for OptionsSetSftpValue {
6583        fn from(value: bool) -> Self {
6584            Self::Variant3(value)
6585        }
6586    }
6587
6588    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetSftpValue {
6589        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6590            Self::Variant4(value)
6591        }
6592    }
6593
6594    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6595        for OptionsSetSftpValue
6596    {
6597        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6598            Self::Variant5(value)
6599        }
6600    }
6601
6602    ///`OptionsSetVfsValue`
6603    ///
6604    /// <details><summary>JSON schema</summary>
6605    ///
6606    /// ```json
6607    ///{
6608    ///  "oneOf": [
6609    ///    {
6610    ///      "type": "string"
6611    ///    },
6612    ///    {
6613    ///      "type": "number"
6614    ///    },
6615    ///    {
6616    ///      "type": "integer"
6617    ///    },
6618    ///    {
6619    ///      "type": "boolean"
6620    ///    },
6621    ///    {
6622    ///      "type": "array",
6623    ///      "items": {}
6624    ///    },
6625    ///    {
6626    ///      "type": "object",
6627    ///      "additionalProperties": {}
6628    ///    }
6629    ///  ]
6630    ///}
6631    /// ```
6632    /// </details>
6633    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6634    #[serde(untagged)]
6635    pub enum OptionsSetVfsValue {
6636        Variant0(::std::string::String),
6637        Variant1(f64),
6638        Variant2(i64),
6639        Variant3(bool),
6640        Variant4(::std::vec::Vec<::serde_json::Value>),
6641        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6642    }
6643
6644    impl ::std::convert::From<&Self> for OptionsSetVfsValue {
6645        fn from(value: &OptionsSetVfsValue) -> Self {
6646            value.clone()
6647        }
6648    }
6649
6650    impl ::std::convert::From<f64> for OptionsSetVfsValue {
6651        fn from(value: f64) -> Self {
6652            Self::Variant1(value)
6653        }
6654    }
6655
6656    impl ::std::convert::From<i64> for OptionsSetVfsValue {
6657        fn from(value: i64) -> Self {
6658            Self::Variant2(value)
6659        }
6660    }
6661
6662    impl ::std::convert::From<bool> for OptionsSetVfsValue {
6663        fn from(value: bool) -> Self {
6664            Self::Variant3(value)
6665        }
6666    }
6667
6668    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetVfsValue {
6669        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6670            Self::Variant4(value)
6671        }
6672    }
6673
6674    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6675        for OptionsSetVfsValue
6676    {
6677        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6678            Self::Variant5(value)
6679        }
6680    }
6681
6682    ///`OptionsSetWebdavValue`
6683    ///
6684    /// <details><summary>JSON schema</summary>
6685    ///
6686    /// ```json
6687    ///{
6688    ///  "oneOf": [
6689    ///    {
6690    ///      "type": "string"
6691    ///    },
6692    ///    {
6693    ///      "type": "number"
6694    ///    },
6695    ///    {
6696    ///      "type": "integer"
6697    ///    },
6698    ///    {
6699    ///      "type": "boolean"
6700    ///    },
6701    ///    {
6702    ///      "type": "array",
6703    ///      "items": {}
6704    ///    },
6705    ///    {
6706    ///      "type": "object",
6707    ///      "additionalProperties": {}
6708    ///    }
6709    ///  ]
6710    ///}
6711    /// ```
6712    /// </details>
6713    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6714    #[serde(untagged)]
6715    pub enum OptionsSetWebdavValue {
6716        Variant0(::std::string::String),
6717        Variant1(f64),
6718        Variant2(i64),
6719        Variant3(bool),
6720        Variant4(::std::vec::Vec<::serde_json::Value>),
6721        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6722    }
6723
6724    impl ::std::convert::From<&Self> for OptionsSetWebdavValue {
6725        fn from(value: &OptionsSetWebdavValue) -> Self {
6726            value.clone()
6727        }
6728    }
6729
6730    impl ::std::convert::From<f64> for OptionsSetWebdavValue {
6731        fn from(value: f64) -> Self {
6732            Self::Variant1(value)
6733        }
6734    }
6735
6736    impl ::std::convert::From<i64> for OptionsSetWebdavValue {
6737        fn from(value: i64) -> Self {
6738            Self::Variant2(value)
6739        }
6740    }
6741
6742    impl ::std::convert::From<bool> for OptionsSetWebdavValue {
6743        fn from(value: bool) -> Self {
6744            Self::Variant3(value)
6745        }
6746    }
6747
6748    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetWebdavValue {
6749        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6750            Self::Variant4(value)
6751        }
6752    }
6753
6754    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6755        for OptionsSetWebdavValue
6756    {
6757        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6758            Self::Variant5(value)
6759        }
6760    }
6761
6762    ///`PluginsctlGetPluginsForTypeResponse`
6763    ///
6764    /// <details><summary>JSON schema</summary>
6765    ///
6766    /// ```json
6767    ///{
6768    ///  "type": "object",
6769    ///  "required": [
6770    ///    "loadedPlugins",
6771    ///    "loadedTestPlugins"
6772    ///  ],
6773    ///  "properties": {
6774    ///    "loadedPlugins": {
6775    ///      "description": "Installed plugins keyed by repository name.",
6776    ///      "type": "object",
6777    ///      "additionalProperties": {
6778    ///        "type": "object",
6779    ///        "additionalProperties": true
6780    ///      }
6781    ///    },
6782    ///    "loadedTestPlugins": {
6783    ///      "description": "Installed test plugins keyed by repository name.",
6784    ///      "type": "object",
6785    ///      "additionalProperties": {
6786    ///        "type": "object",
6787    ///        "additionalProperties": true
6788    ///      }
6789    ///    }
6790    ///  }
6791    ///}
6792    /// ```
6793    /// </details>
6794    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6795    pub struct PluginsctlGetPluginsForTypeResponse {
6796        ///Installed plugins keyed by repository name.
6797        #[serde(rename = "loadedPlugins")]
6798        pub loaded_plugins: ::std::collections::HashMap<
6799            ::std::string::String,
6800            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6801        >,
6802        ///Installed test plugins keyed by repository name.
6803        #[serde(rename = "loadedTestPlugins")]
6804        pub loaded_test_plugins: ::std::collections::HashMap<
6805            ::std::string::String,
6806            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6807        >,
6808    }
6809
6810    impl ::std::convert::From<&PluginsctlGetPluginsForTypeResponse>
6811        for PluginsctlGetPluginsForTypeResponse
6812    {
6813        fn from(value: &PluginsctlGetPluginsForTypeResponse) -> Self {
6814            value.clone()
6815        }
6816    }
6817
6818    ///`PluginsctlListPluginsResponse`
6819    ///
6820    /// <details><summary>JSON schema</summary>
6821    ///
6822    /// ```json
6823    ///{
6824    ///  "type": "object",
6825    ///  "required": [
6826    ///    "loadedPlugins",
6827    ///    "testPlugins"
6828    ///  ],
6829    ///  "properties": {
6830    ///    "loadedPlugins": {
6831    ///      "description": "Metadata entries for installed plugins.",
6832    ///      "type": "array",
6833    ///      "items": {
6834    ///        "type": "object",
6835    ///        "additionalProperties": true
6836    ///      }
6837    ///    },
6838    ///    "testPlugins": {
6839    ///      "description": "Metadata entries for installed test plugins.",
6840    ///      "type": "array",
6841    ///      "items": {
6842    ///        "type": "object",
6843    ///        "additionalProperties": true
6844    ///      }
6845    ///    }
6846    ///  }
6847    ///}
6848    /// ```
6849    /// </details>
6850    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6851    pub struct PluginsctlListPluginsResponse {
6852        ///Metadata entries for installed plugins.
6853        #[serde(rename = "loadedPlugins")]
6854        pub loaded_plugins:
6855            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6856        ///Metadata entries for installed test plugins.
6857        #[serde(rename = "testPlugins")]
6858        pub test_plugins:
6859            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6860    }
6861
6862    impl ::std::convert::From<&PluginsctlListPluginsResponse> for PluginsctlListPluginsResponse {
6863        fn from(value: &PluginsctlListPluginsResponse) -> Self {
6864            value.clone()
6865        }
6866    }
6867
6868    ///`PluginsctlListTestPluginsResponse`
6869    ///
6870    /// <details><summary>JSON schema</summary>
6871    ///
6872    /// ```json
6873    ///{
6874    ///  "type": "object",
6875    ///  "required": [
6876    ///    "loadedTestPlugins"
6877    ///  ],
6878    ///  "properties": {
6879    ///    "loadedTestPlugins": {
6880    ///      "description": "Installed test plugin metadata keyed by
6881    /// repository.",
6882    ///      "type": "object",
6883    ///      "additionalProperties": {
6884    ///        "type": "object",
6885    ///        "additionalProperties": true
6886    ///      }
6887    ///    }
6888    ///  }
6889    ///}
6890    /// ```
6891    /// </details>
6892    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6893    pub struct PluginsctlListTestPluginsResponse {
6894        ///Installed test plugin metadata keyed by repository.
6895        #[serde(rename = "loadedTestPlugins")]
6896        pub loaded_test_plugins: ::std::collections::HashMap<
6897            ::std::string::String,
6898            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6899        >,
6900    }
6901
6902    impl ::std::convert::From<&PluginsctlListTestPluginsResponse>
6903        for PluginsctlListTestPluginsResponse
6904    {
6905        fn from(value: &PluginsctlListTestPluginsResponse) -> Self {
6906            value.clone()
6907        }
6908    }
6909
6910    ///`RcError`
6911    ///
6912    /// <details><summary>JSON schema</summary>
6913    ///
6914    /// ```json
6915    ///{
6916    ///  "type": "object",
6917    ///  "required": [
6918    ///    "error",
6919    ///    "input",
6920    ///    "path",
6921    ///    "status"
6922    ///  ],
6923    ///  "properties": {
6924    ///    "error": {
6925    ///      "type": "string"
6926    ///    },
6927    ///    "input": {
6928    ///      "description": "Original request parameters echoed for debugging.",
6929    ///      "type": [
6930    ///        "object",
6931    ///        "null"
6932    ///      ],
6933    ///      "additionalProperties": {}
6934    ///    },
6935    ///    "path": {
6936    ///      "type": "string"
6937    ///    },
6938    ///    "status": {
6939    ///      "type": "integer"
6940    ///    }
6941    ///  }
6942    ///}
6943    /// ```
6944    /// </details>
6945    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6946    pub struct RcError {
6947        pub error: ::std::string::String,
6948        ///Original request parameters echoed for debugging.
6949        pub input:
6950            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6951        pub path: ::std::string::String,
6952        pub status: i64,
6953    }
6954
6955    impl ::std::convert::From<&RcError> for RcError {
6956        fn from(value: &RcError) -> Self {
6957            value.clone()
6958        }
6959    }
6960
6961    ///`RcListResponse`
6962    ///
6963    /// <details><summary>JSON schema</summary>
6964    ///
6965    /// ```json
6966    ///{
6967    ///  "type": "object",
6968    ///  "required": [
6969    ///    "commands"
6970    ///  ],
6971    ///  "properties": {
6972    ///    "commands": {
6973    ///      "type": "array",
6974    ///      "items": {
6975    ///        "type": "object",
6976    ///        "properties": {
6977    ///          "AuthRequired": {
6978    ///            "type": "boolean"
6979    ///          },
6980    ///          "Help": {
6981    ///            "type": "string"
6982    ///          },
6983    ///          "NeedsRequest": {
6984    ///            "type": "boolean"
6985    ///          },
6986    ///          "NeedsResponse": {
6987    ///            "type": "boolean"
6988    ///          },
6989    ///          "Path": {
6990    ///            "type": "string"
6991    ///          },
6992    ///          "Title": {
6993    ///            "type": "string"
6994    ///          }
6995    ///        },
6996    ///        "additionalProperties": true
6997    ///      }
6998    ///    }
6999    ///  }
7000    ///}
7001    /// ```
7002    /// </details>
7003    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7004    pub struct RcListResponse {
7005        pub commands: ::std::vec::Vec<RcListResponseCommandsItem>,
7006    }
7007
7008    impl ::std::convert::From<&RcListResponse> for RcListResponse {
7009        fn from(value: &RcListResponse) -> Self {
7010            value.clone()
7011        }
7012    }
7013
7014    ///`RcListResponseCommandsItem`
7015    ///
7016    /// <details><summary>JSON schema</summary>
7017    ///
7018    /// ```json
7019    ///{
7020    ///  "type": "object",
7021    ///  "properties": {
7022    ///    "AuthRequired": {
7023    ///      "type": "boolean"
7024    ///    },
7025    ///    "Help": {
7026    ///      "type": "string"
7027    ///    },
7028    ///    "NeedsRequest": {
7029    ///      "type": "boolean"
7030    ///    },
7031    ///    "NeedsResponse": {
7032    ///      "type": "boolean"
7033    ///    },
7034    ///    "Path": {
7035    ///      "type": "string"
7036    ///    },
7037    ///    "Title": {
7038    ///      "type": "string"
7039    ///    }
7040    ///  },
7041    ///  "additionalProperties": true
7042    ///}
7043    /// ```
7044    /// </details>
7045    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7046    pub struct RcListResponseCommandsItem {
7047        #[serde(
7048            rename = "AuthRequired",
7049            default,
7050            skip_serializing_if = "::std::option::Option::is_none"
7051        )]
7052        pub auth_required: ::std::option::Option<bool>,
7053        #[serde(
7054            rename = "Help",
7055            default,
7056            skip_serializing_if = "::std::option::Option::is_none"
7057        )]
7058        pub help: ::std::option::Option<::std::string::String>,
7059        #[serde(
7060            rename = "NeedsRequest",
7061            default,
7062            skip_serializing_if = "::std::option::Option::is_none"
7063        )]
7064        pub needs_request: ::std::option::Option<bool>,
7065        #[serde(
7066            rename = "NeedsResponse",
7067            default,
7068            skip_serializing_if = "::std::option::Option::is_none"
7069        )]
7070        pub needs_response: ::std::option::Option<bool>,
7071        #[serde(
7072            rename = "Path",
7073            default,
7074            skip_serializing_if = "::std::option::Option::is_none"
7075        )]
7076        pub path: ::std::option::Option<::std::string::String>,
7077        #[serde(
7078            rename = "Title",
7079            default,
7080            skip_serializing_if = "::std::option::Option::is_none"
7081        )]
7082        pub title: ::std::option::Option<::std::string::String>,
7083    }
7084
7085    impl ::std::convert::From<&RcListResponseCommandsItem> for RcListResponseCommandsItem {
7086        fn from(value: &RcListResponseCommandsItem) -> Self {
7087            value.clone()
7088        }
7089    }
7090
7091    impl ::std::default::Default for RcListResponseCommandsItem {
7092        fn default() -> Self {
7093            Self {
7094                auth_required: Default::default(),
7095                help: Default::default(),
7096                needs_request: Default::default(),
7097                needs_response: Default::default(),
7098                path: Default::default(),
7099                title: Default::default(),
7100            }
7101        }
7102    }
7103
7104    ///`ServeListResponse`
7105    ///
7106    /// <details><summary>JSON schema</summary>
7107    ///
7108    /// ```json
7109    ///{
7110    ///  "type": "object",
7111    ///  "required": [
7112    ///    "list"
7113    ///  ],
7114    ///  "properties": {
7115    ///    "list": {
7116    ///      "type": "array",
7117    ///      "items": {
7118    ///        "type": "object",
7119    ///        "required": [
7120    ///          "addr",
7121    ///          "id"
7122    ///        ],
7123    ///        "properties": {
7124    ///          "addr": {
7125    ///            "description": "Address and port the server is listening
7126    /// on.",
7127    ///            "type": "string"
7128    ///          },
7129    ///          "id": {
7130    ///            "description": "Identifier returned by `serve/start`.",
7131    ///            "type": "string"
7132    ///          },
7133    ///          "params": {
7134    ///            "description": "Serve configuration parameters supplied at
7135    /// startup.",
7136    ///            "type": "object",
7137    ///            "required": [
7138    ///              "fs",
7139    ///              "id",
7140    ///              "type"
7141    ///            ],
7142    ///            "properties": {
7143    ///              "fs": {
7144    ///                "type": "string"
7145    ///              },
7146    ///              "opt": {
7147    ///                "type": "object",
7148    ///                "additionalProperties": true
7149    ///              },
7150    ///              "type": {
7151    ///                "type": "string"
7152    ///              },
7153    ///              "vfsOpt": {
7154    ///                "type": "object",
7155    ///                "additionalProperties": true
7156    ///              }
7157    ///            },
7158    ///            "additionalProperties": true
7159    ///          }
7160    ///        },
7161    ///        "additionalProperties": false
7162    ///      }
7163    ///    }
7164    ///  }
7165    ///}
7166    /// ```
7167    /// </details>
7168    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7169    pub struct ServeListResponse {
7170        pub list: ::std::vec::Vec<ServeListResponseListItem>,
7171    }
7172
7173    impl ::std::convert::From<&ServeListResponse> for ServeListResponse {
7174        fn from(value: &ServeListResponse) -> Self {
7175            value.clone()
7176        }
7177    }
7178
7179    ///`ServeListResponseListItem`
7180    ///
7181    /// <details><summary>JSON schema</summary>
7182    ///
7183    /// ```json
7184    ///{
7185    ///  "type": "object",
7186    ///  "required": [
7187    ///    "addr",
7188    ///    "id"
7189    ///  ],
7190    ///  "properties": {
7191    ///    "addr": {
7192    ///      "description": "Address and port the server is listening on.",
7193    ///      "type": "string"
7194    ///    },
7195    ///    "id": {
7196    ///      "description": "Identifier returned by `serve/start`.",
7197    ///      "type": "string"
7198    ///    },
7199    ///    "params": {
7200    ///      "description": "Serve configuration parameters supplied at
7201    /// startup.",
7202    ///      "type": "object",
7203    ///      "required": [
7204    ///        "fs",
7205    ///        "id",
7206    ///        "type"
7207    ///      ],
7208    ///      "properties": {
7209    ///        "fs": {
7210    ///          "type": "string"
7211    ///        },
7212    ///        "opt": {
7213    ///          "type": "object",
7214    ///          "additionalProperties": true
7215    ///        },
7216    ///        "type": {
7217    ///          "type": "string"
7218    ///        },
7219    ///        "vfsOpt": {
7220    ///          "type": "object",
7221    ///          "additionalProperties": true
7222    ///        }
7223    ///      },
7224    ///      "additionalProperties": true
7225    ///    }
7226    ///  },
7227    ///  "additionalProperties": false
7228    ///}
7229    /// ```
7230    /// </details>
7231    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7232    #[serde(deny_unknown_fields)]
7233    pub struct ServeListResponseListItem {
7234        ///Address and port the server is listening on.
7235        pub addr: ::std::string::String,
7236        ///Identifier returned by `serve/start`.
7237        pub id: ::std::string::String,
7238        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7239        pub params: ::std::option::Option<ServeListResponseListItemParams>,
7240    }
7241
7242    impl ::std::convert::From<&ServeListResponseListItem> for ServeListResponseListItem {
7243        fn from(value: &ServeListResponseListItem) -> Self {
7244            value.clone()
7245        }
7246    }
7247
7248    ///Serve configuration parameters supplied at startup.
7249    ///
7250    /// <details><summary>JSON schema</summary>
7251    ///
7252    /// ```json
7253    ///{
7254    ///  "description": "Serve configuration parameters supplied at startup.",
7255    ///  "type": "object",
7256    ///  "required": [
7257    ///    "fs",
7258    ///    "id",
7259    ///    "type"
7260    ///  ],
7261    ///  "properties": {
7262    ///    "fs": {
7263    ///      "type": "string"
7264    ///    },
7265    ///    "opt": {
7266    ///      "type": "object",
7267    ///      "additionalProperties": true
7268    ///    },
7269    ///    "type": {
7270    ///      "type": "string"
7271    ///    },
7272    ///    "vfsOpt": {
7273    ///      "type": "object",
7274    ///      "additionalProperties": true
7275    ///    }
7276    ///  },
7277    ///  "additionalProperties": true
7278    ///}
7279    /// ```
7280    /// </details>
7281    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7282    pub struct ServeListResponseListItemParams {
7283        pub fs: ::std::string::String,
7284        pub id: ::serde_json::Value,
7285        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
7286        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7287        #[serde(rename = "type")]
7288        pub type_: ::std::string::String,
7289        #[serde(
7290            rename = "vfsOpt",
7291            default,
7292            skip_serializing_if = "::serde_json::Map::is_empty"
7293        )]
7294        pub vfs_opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7295    }
7296
7297    impl ::std::convert::From<&ServeListResponseListItemParams> for ServeListResponseListItemParams {
7298        fn from(value: &ServeListResponseListItemParams) -> Self {
7299            value.clone()
7300        }
7301    }
7302
7303    ///`ServeStartResponse`
7304    ///
7305    /// <details><summary>JSON schema</summary>
7306    ///
7307    /// ```json
7308    ///{
7309    ///  "type": "object",
7310    ///  "required": [
7311    ///    "addr",
7312    ///    "id"
7313    ///  ],
7314    ///  "properties": {
7315    ///    "addr": {
7316    ///      "description": "Address and port the server is listening on.",
7317    ///      "type": "string"
7318    ///    },
7319    ///    "id": {
7320    ///      "description": "Identifier to pass to `serve/stop`.",
7321    ///      "type": "string"
7322    ///    }
7323    ///  }
7324    ///}
7325    /// ```
7326    /// </details>
7327    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7328    pub struct ServeStartResponse {
7329        ///Address and port the server is listening on.
7330        pub addr: ::std::string::String,
7331        ///Identifier to pass to `serve/stop`.
7332        pub id: ::std::string::String,
7333    }
7334
7335    impl ::std::convert::From<&ServeStartResponse> for ServeStartResponse {
7336        fn from(value: &ServeStartResponse) -> Self {
7337            value.clone()
7338        }
7339    }
7340
7341    ///`SyncBisyncResponse`
7342    ///
7343    /// <details><summary>JSON schema</summary>
7344    ///
7345    /// ```json
7346    ///{
7347    ///  "type": "object",
7348    ///  "properties": {
7349    ///    "jobid": {
7350    ///      "description": "Job ID of the operation.",
7351    ///      "type": "integer"
7352    ///    }
7353    ///  }
7354    ///}
7355    /// ```
7356    /// </details>
7357    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7358    pub struct SyncBisyncResponse {
7359        ///Job ID of the operation.
7360        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7361        pub jobid: ::std::option::Option<i64>,
7362    }
7363
7364    impl ::std::convert::From<&SyncBisyncResponse> for SyncBisyncResponse {
7365        fn from(value: &SyncBisyncResponse) -> Self {
7366            value.clone()
7367        }
7368    }
7369
7370    impl ::std::default::Default for SyncBisyncResponse {
7371        fn default() -> Self {
7372            Self {
7373                jobid: Default::default(),
7374            }
7375        }
7376    }
7377
7378    ///`SyncCopyResponse`
7379    ///
7380    /// <details><summary>JSON schema</summary>
7381    ///
7382    /// ```json
7383    ///{
7384    ///  "type": "object",
7385    ///  "properties": {
7386    ///    "jobid": {
7387    ///      "description": "Job ID of the operation.",
7388    ///      "type": "integer"
7389    ///    }
7390    ///  }
7391    ///}
7392    /// ```
7393    /// </details>
7394    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7395    pub struct SyncCopyResponse {
7396        ///Job ID of the operation.
7397        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7398        pub jobid: ::std::option::Option<i64>,
7399    }
7400
7401    impl ::std::convert::From<&SyncCopyResponse> for SyncCopyResponse {
7402        fn from(value: &SyncCopyResponse) -> Self {
7403            value.clone()
7404        }
7405    }
7406
7407    impl ::std::default::Default for SyncCopyResponse {
7408        fn default() -> Self {
7409            Self {
7410                jobid: Default::default(),
7411            }
7412        }
7413    }
7414
7415    ///`SyncMoveResponse`
7416    ///
7417    /// <details><summary>JSON schema</summary>
7418    ///
7419    /// ```json
7420    ///{
7421    ///  "type": "object",
7422    ///  "properties": {
7423    ///    "jobid": {
7424    ///      "description": "Job ID of the operation.",
7425    ///      "type": "integer"
7426    ///    }
7427    ///  }
7428    ///}
7429    /// ```
7430    /// </details>
7431    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7432    pub struct SyncMoveResponse {
7433        ///Job ID of the operation.
7434        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7435        pub jobid: ::std::option::Option<i64>,
7436    }
7437
7438    impl ::std::convert::From<&SyncMoveResponse> for SyncMoveResponse {
7439        fn from(value: &SyncMoveResponse) -> Self {
7440            value.clone()
7441        }
7442    }
7443
7444    impl ::std::default::Default for SyncMoveResponse {
7445        fn default() -> Self {
7446            Self {
7447                jobid: Default::default(),
7448            }
7449        }
7450    }
7451
7452    ///`SyncSyncResponse`
7453    ///
7454    /// <details><summary>JSON schema</summary>
7455    ///
7456    /// ```json
7457    ///{
7458    ///  "type": "object",
7459    ///  "properties": {
7460    ///    "jobid": {
7461    ///      "description": "Job ID of the operation.",
7462    ///      "type": "integer"
7463    ///    }
7464    ///  }
7465    ///}
7466    /// ```
7467    /// </details>
7468    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7469    pub struct SyncSyncResponse {
7470        ///Job ID of the operation.
7471        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7472        pub jobid: ::std::option::Option<i64>,
7473    }
7474
7475    impl ::std::convert::From<&SyncSyncResponse> for SyncSyncResponse {
7476        fn from(value: &SyncSyncResponse) -> Self {
7477            value.clone()
7478        }
7479    }
7480
7481    impl ::std::default::Default for SyncSyncResponse {
7482        fn default() -> Self {
7483            Self {
7484                jobid: Default::default(),
7485            }
7486        }
7487    }
7488
7489    ///`VfsForgetResponse`
7490    ///
7491    /// <details><summary>JSON schema</summary>
7492    ///
7493    /// ```json
7494    ///{
7495    ///  "type": "object",
7496    ///  "required": [
7497    ///    "forgotten"
7498    ///  ],
7499    ///  "properties": {
7500    ///    "forgotten": {
7501    ///      "description": "Paths that were successfully forgotten.",
7502    ///      "type": "array",
7503    ///      "items": {
7504    ///        "type": "string"
7505    ///      }
7506    ///    }
7507    ///  }
7508    ///}
7509    /// ```
7510    /// </details>
7511    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7512    pub struct VfsForgetResponse {
7513        ///Paths that were successfully forgotten.
7514        pub forgotten: ::std::vec::Vec<::std::string::String>,
7515    }
7516
7517    impl ::std::convert::From<&VfsForgetResponse> for VfsForgetResponse {
7518        fn from(value: &VfsForgetResponse) -> Self {
7519            value.clone()
7520        }
7521    }
7522
7523    ///`VfsListResponse`
7524    ///
7525    /// <details><summary>JSON schema</summary>
7526    ///
7527    /// ```json
7528    ///{
7529    ///  "type": "object",
7530    ///  "required": [
7531    ///    "vfses"
7532    ///  ],
7533    ///  "properties": {
7534    ///    "vfses": {
7535    ///      "description": "VFS name that can be used with other VFS
7536    /// endpoints.",
7537    ///      "type": "array",
7538    ///      "items": {
7539    ///        "type": "string"
7540    ///      }
7541    ///    }
7542    ///  }
7543    ///}
7544    /// ```
7545    /// </details>
7546    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7547    pub struct VfsListResponse {
7548        ///VFS name that can be used with other VFS endpoints.
7549        pub vfses: ::std::vec::Vec<::std::string::String>,
7550    }
7551
7552    impl ::std::convert::From<&VfsListResponse> for VfsListResponse {
7553        fn from(value: &VfsListResponse) -> Self {
7554            value.clone()
7555        }
7556    }
7557
7558    ///`VfsQueueResponse`
7559    ///
7560    /// <details><summary>JSON schema</summary>
7561    ///
7562    /// ```json
7563    ///{
7564    ///  "type": "object",
7565    ///  "properties": {
7566    ///    "queued": {
7567    ///      "type": "array",
7568    ///      "items": {
7569    ///        "description": "Queued item metadata such as name, size, expiry,
7570    /// and upload state.",
7571    ///        "type": "object",
7572    ///        "additionalProperties": true
7573    ///      }
7574    ///    }
7575    ///  }
7576    ///}
7577    /// ```
7578    /// </details>
7579    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7580    pub struct VfsQueueResponse {
7581        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7582        pub queued: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7583    }
7584
7585    impl ::std::convert::From<&VfsQueueResponse> for VfsQueueResponse {
7586        fn from(value: &VfsQueueResponse) -> Self {
7587            value.clone()
7588        }
7589    }
7590
7591    impl ::std::default::Default for VfsQueueResponse {
7592        fn default() -> Self {
7593            Self {
7594                queued: Default::default(),
7595            }
7596        }
7597    }
7598
7599    ///`VfsRefreshResponse`
7600    ///
7601    /// <details><summary>JSON schema</summary>
7602    ///
7603    /// ```json
7604    ///{
7605    ///  "type": "object",
7606    ///  "required": [
7607    ///    "result"
7608    ///  ],
7609    ///  "properties": {
7610    ///    "result": {
7611    ///      "description": "Map of refreshed directories to status messages.",
7612    ///      "type": "object",
7613    ///      "additionalProperties": {
7614    ///        "type": "string"
7615    ///      }
7616    ///    }
7617    ///  }
7618    ///}
7619    /// ```
7620    /// </details>
7621    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7622    pub struct VfsRefreshResponse {
7623        ///Map of refreshed directories to status messages.
7624        pub result: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
7625    }
7626
7627    impl ::std::convert::From<&VfsRefreshResponse> for VfsRefreshResponse {
7628        fn from(value: &VfsRefreshResponse) -> Self {
7629            value.clone()
7630        }
7631    }
7632
7633    ///`VfsStatsResponse`
7634    ///
7635    /// <details><summary>JSON schema</summary>
7636    ///
7637    /// ```json
7638    ///{
7639    ///  "type": "object",
7640    ///  "required": [
7641    ///    "fs",
7642    ///    "inUse",
7643    ///    "metadataCache",
7644    ///    "opt"
7645    ///  ],
7646    ///  "properties": {
7647    ///    "diskCache": {
7648    ///      "description": "Disk cache metrics when caching is enabled.",
7649    ///      "type": [
7650    ///        "object",
7651    ///        "null"
7652    ///      ],
7653    ///      "additionalProperties": true
7654    ///    },
7655    ///    "fs": {
7656    ///      "description": "Name of the VFS.",
7657    ///      "type": "string"
7658    ///    },
7659    ///    "inUse": {
7660    ///      "description": "Number of active references to the VFS.",
7661    ///      "type": "integer"
7662    ///    },
7663    ///    "metadataCache": {
7664    ///      "description": "In-memory metadata cache counters.",
7665    ///      "type": "object",
7666    ///      "additionalProperties": {
7667    ///        "type": "integer"
7668    ///      }
7669    ///    },
7670    ///    "opt": {
7671    ///      "description": "Effective options applied to the VFS.",
7672    ///      "type": "object",
7673    ///      "additionalProperties": true
7674    ///    }
7675    ///  }
7676    ///}
7677    /// ```
7678    /// </details>
7679    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7680    pub struct VfsStatsResponse {
7681        ///Disk cache metrics when caching is enabled.
7682        #[serde(
7683            rename = "diskCache",
7684            default,
7685            skip_serializing_if = "::std::option::Option::is_none"
7686        )]
7687        pub disk_cache:
7688            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7689        ///Name of the VFS.
7690        pub fs: ::std::string::String,
7691        ///Number of active references to the VFS.
7692        #[serde(rename = "inUse")]
7693        pub in_use: i64,
7694        ///In-memory metadata cache counters.
7695        #[serde(rename = "metadataCache")]
7696        pub metadata_cache: ::std::collections::HashMap<::std::string::String, i64>,
7697        ///Effective options applied to the VFS.
7698        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7699    }
7700
7701    impl ::std::convert::From<&VfsStatsResponse> for VfsStatsResponse {
7702        fn from(value: &VfsStatsResponse) -> Self {
7703            value.clone()
7704        }
7705    }
7706}
7707
7708#[derive(Clone, Debug)]
7709///Client for Rclone RC API
7710///
7711///Full OpenAPI specification for the Rclone RC API.
7712///
7713///Version: 0.1.3
7714pub struct Client {
7715    pub(crate) baseurl: String,
7716    pub(crate) client: reqwest::Client,
7717}
7718
7719impl Client {
7720    /// Create a new client.
7721    ///
7722    /// `baseurl` is the base URL provided to the internal
7723    /// `reqwest::Client`, and should include a scheme and hostname,
7724    /// as well as port and a path stem if applicable.
7725    pub fn new(baseurl: &str) -> Self {
7726        #[cfg(not(target_arch = "wasm32"))]
7727        let client = {
7728            let dur = ::std::time::Duration::from_secs(15u64);
7729            reqwest::ClientBuilder::new()
7730                .connect_timeout(dur)
7731                .timeout(dur)
7732        };
7733        #[cfg(target_arch = "wasm32")]
7734        let client = reqwest::ClientBuilder::new();
7735        Self::new_with_client(baseurl, client.build().unwrap())
7736    }
7737
7738    /// Construct a new client with an existing `reqwest::Client`,
7739    /// allowing more control over its configuration.
7740    ///
7741    /// `baseurl` is the base URL provided to the internal
7742    /// `reqwest::Client`, and should include a scheme and hostname,
7743    /// as well as port and a path stem if applicable.
7744    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
7745        Self {
7746            baseurl: baseurl.to_string(),
7747            client,
7748        }
7749    }
7750}
7751
7752impl ClientInfo<()> for Client {
7753    fn api_version() -> &'static str {
7754        "0.1.3"
7755    }
7756
7757    fn baseurl(&self) -> &str {
7758        self.baseurl.as_str()
7759    }
7760
7761    fn client(&self) -> &reqwest::Client {
7762        &self.client
7763    }
7764
7765    fn inner(&self) -> &() {
7766        &()
7767    }
7768}
7769
7770impl ClientHooks<()> for &Client {}
7771#[allow(clippy::all)]
7772impl Client {
7773    ///Echo request parameters
7774    ///
7775    ///Returns all supplied parameters unchanged so you can verify RC
7776    /// connectivity.
7777    ///
7778    ///Sends a `POST` request to `/rc/noop`
7779    ///
7780    ///Arguments:
7781    /// - `async_`: Run the command asynchronously. Returns a job id
7782    ///   immediately.
7783    /// - `params`: Additional arbitrary parameters allowed.
7784    pub async fn rc_noop<'a>(
7785        &'a self,
7786        async_: Option<bool>,
7787        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7788    ) -> Result<
7789        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7790        Error<types::RcError>,
7791    > {
7792        let url = format!("{}/rc/noop", self.baseurl,);
7793        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7794        header_map.append(
7795            ::reqwest::header::HeaderName::from_static("api-version"),
7796            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7797        );
7798        #[allow(unused_mut)]
7799        let mut request = self
7800            .client
7801            .post(url)
7802            .header(
7803                ::reqwest::header::ACCEPT,
7804                ::reqwest::header::HeaderValue::from_static("application/json"),
7805            )
7806            .query(&progenitor_client::QueryParam::new("_async", &async_))
7807            .query(&progenitor_client::QueryParam::new("params", &params))
7808            .headers(header_map)
7809            .build()?;
7810        let info = OperationInfo {
7811            operation_id: "rc_noop",
7812        };
7813        self.pre(&mut request, &info).await?;
7814        let result = self.exec(request, &info).await;
7815        self.post(&result, &info).await?;
7816        let response = result?;
7817        match response.status().as_u16() {
7818            200u16 => ResponseValue::from_response(response).await,
7819            400u16..=499u16 => Err(Error::ErrorResponse(
7820                ResponseValue::from_response(response).await?,
7821            )),
7822            500u16..=599u16 => Err(Error::ErrorResponse(
7823                ResponseValue::from_response(response).await?,
7824            )),
7825            _ => Err(Error::UnexpectedResponse(response)),
7826        }
7827    }
7828
7829    ///Remove trashed files
7830    ///
7831    ///Permanently removes trashed objects from the specified remote path.
7832    ///
7833    ///Sends a `POST` request to `/operations/cleanup`
7834    ///
7835    ///Arguments:
7836    /// - `async_`: Run the command asynchronously. Returns a job id
7837    ///   immediately.
7838    /// - `group`: Assign the request to a custom stats group.
7839    /// - `fs`: Remote name or path to clean up, for example `drive:`.
7840    pub async fn operations_cleanup<'a>(
7841        &'a self,
7842        async_: Option<bool>,
7843        group: Option<&'a str>,
7844        fs: &'a str,
7845    ) -> Result<
7846        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7847        Error<types::RcError>,
7848    > {
7849        let url = format!("{}/operations/cleanup", self.baseurl,);
7850        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7851        header_map.append(
7852            ::reqwest::header::HeaderName::from_static("api-version"),
7853            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7854        );
7855        #[allow(unused_mut)]
7856        let mut request = self
7857            .client
7858            .post(url)
7859            .header(
7860                ::reqwest::header::ACCEPT,
7861                ::reqwest::header::HeaderValue::from_static("application/json"),
7862            )
7863            .query(&progenitor_client::QueryParam::new("_async", &async_))
7864            .query(&progenitor_client::QueryParam::new("_group", &group))
7865            .query(&progenitor_client::QueryParam::new("fs", &fs))
7866            .headers(header_map)
7867            .build()?;
7868        let info = OperationInfo {
7869            operation_id: "operations_cleanup",
7870        };
7871        self.pre(&mut request, &info).await?;
7872        let result = self.exec(request, &info).await;
7873        self.post(&result, &info).await?;
7874        let response = result?;
7875        match response.status().as_u16() {
7876            200u16 => ResponseValue::from_response(response).await,
7877            400u16..=499u16 => Err(Error::ErrorResponse(
7878                ResponseValue::from_response(response).await?,
7879            )),
7880            500u16..=599u16 => Err(Error::ErrorResponse(
7881                ResponseValue::from_response(response).await?,
7882            )),
7883            _ => Err(Error::UnexpectedResponse(response)),
7884        }
7885    }
7886
7887    ///Copy a single file
7888    ///
7889    ///Copies one object from a source remote and path to a destination remote
7890    /// and path.
7891    ///
7892    ///Sends a `POST` request to `/operations/copyfile`
7893    ///
7894    ///Arguments:
7895    /// - `async_`: Run the command asynchronously. Returns a job id
7896    ///   immediately.
7897    /// - `group`: Assign the request to a custom stats group.
7898    /// - `dst_fs`: Destination remote name or path, such as `drive2:` or `/`
7899    ///   for local filesystem.
7900    /// - `dst_remote`: Target path within `dstFs` where the file should be
7901    ///   written.
7902    /// - `src_fs`: Source remote name or path, such as `drive:` or `/` for the
7903    ///   local filesystem.
7904    /// - `src_remote`: Path to the source object within `srcFs`, for example
7905    ///   `dir/file.txt`.
7906    pub async fn operations_copyfile<'a>(
7907        &'a self,
7908        async_: Option<bool>,
7909        group: Option<&'a str>,
7910        dst_fs: &'a str,
7911        dst_remote: &'a str,
7912        src_fs: &'a str,
7913        src_remote: &'a str,
7914    ) -> Result<
7915        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7916        Error<types::RcError>,
7917    > {
7918        let url = format!("{}/operations/copyfile", self.baseurl,);
7919        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7920        header_map.append(
7921            ::reqwest::header::HeaderName::from_static("api-version"),
7922            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7923        );
7924        #[allow(unused_mut)]
7925        let mut request = self
7926            .client
7927            .post(url)
7928            .header(
7929                ::reqwest::header::ACCEPT,
7930                ::reqwest::header::HeaderValue::from_static("application/json"),
7931            )
7932            .query(&progenitor_client::QueryParam::new("_async", &async_))
7933            .query(&progenitor_client::QueryParam::new("_group", &group))
7934            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
7935            .query(&progenitor_client::QueryParam::new(
7936                "dstRemote",
7937                &dst_remote,
7938            ))
7939            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
7940            .query(&progenitor_client::QueryParam::new(
7941                "srcRemote",
7942                &src_remote,
7943            ))
7944            .headers(header_map)
7945            .build()?;
7946        let info = OperationInfo {
7947            operation_id: "operations_copyfile",
7948        };
7949        self.pre(&mut request, &info).await?;
7950        let result = self.exec(request, &info).await;
7951        self.post(&result, &info).await?;
7952        let response = result?;
7953        match response.status().as_u16() {
7954            200u16 => ResponseValue::from_response(response).await,
7955            400u16..=499u16 => Err(Error::ErrorResponse(
7956                ResponseValue::from_response(response).await?,
7957            )),
7958            500u16..=599u16 => Err(Error::ErrorResponse(
7959                ResponseValue::from_response(response).await?,
7960            )),
7961            _ => Err(Error::UnexpectedResponse(response)),
7962        }
7963    }
7964
7965    ///Copy from URL
7966    ///
7967    ///Downloads a public URL and stores it at the requested remote path.
7968    ///
7969    ///Sends a `POST` request to `/operations/copyurl`
7970    ///
7971    ///Arguments:
7972    /// - `async_`: Run the command asynchronously. Returns a job id
7973    ///   immediately.
7974    /// - `group`: Assign the request to a custom stats group.
7975    /// - `auto_filename`: Set to true to derive the destination filename from
7976    ///   the URL.
7977    /// - `fs`: Remote name or path that will receive the downloaded file, e.g.
7978    ///   `drive:`.
7979    /// - `remote`: Destination path within `fs` where the fetched object will
7980    ///   be stored.
7981    /// - `url`: Source URL to fetch the object from.
7982    pub async fn operations_copyurl<'a>(
7983        &'a self,
7984        async_: Option<bool>,
7985        group: Option<&'a str>,
7986        auto_filename: Option<bool>,
7987        fs: &'a str,
7988        remote: &'a str,
7989        url: &'a str,
7990    ) -> Result<
7991        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7992        Error<types::RcError>,
7993    > {
7994        let _url = format!("{}/operations/copyurl", self.baseurl,);
7995        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7996        header_map.append(
7997            ::reqwest::header::HeaderName::from_static("api-version"),
7998            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7999        );
8000        #[allow(unused_mut)]
8001        let mut request = self
8002            .client
8003            .post(_url)
8004            .header(
8005                ::reqwest::header::ACCEPT,
8006                ::reqwest::header::HeaderValue::from_static("application/json"),
8007            )
8008            .query(&progenitor_client::QueryParam::new("_async", &async_))
8009            .query(&progenitor_client::QueryParam::new("_group", &group))
8010            .query(&progenitor_client::QueryParam::new(
8011                "autoFilename",
8012                &auto_filename,
8013            ))
8014            .query(&progenitor_client::QueryParam::new("fs", &fs))
8015            .query(&progenitor_client::QueryParam::new("remote", &remote))
8016            .query(&progenitor_client::QueryParam::new("url", &url))
8017            .headers(header_map)
8018            .build()?;
8019        let info = OperationInfo {
8020            operation_id: "operations_copyurl",
8021        };
8022        self.pre(&mut request, &info).await?;
8023        let result = self.exec(request, &info).await;
8024        self.post(&result, &info).await?;
8025        let response = result?;
8026        match response.status().as_u16() {
8027            200u16 => ResponseValue::from_response(response).await,
8028            400u16..=499u16 => Err(Error::ErrorResponse(
8029                ResponseValue::from_response(response).await?,
8030            )),
8031            500u16..=599u16 => Err(Error::ErrorResponse(
8032                ResponseValue::from_response(response).await?,
8033            )),
8034            _ => Err(Error::UnexpectedResponse(response)),
8035        }
8036    }
8037
8038    ///Delete objects in path
8039    ///
8040    ///Deletes matching files and directories for the provided remote,
8041    /// honouring filters and config overrides.
8042    ///
8043    ///Sends a `POST` request to `/operations/delete`
8044    ///
8045    ///Arguments:
8046    /// - `async_`: Run the command asynchronously. Returns a job id
8047    ///   immediately.
8048    /// - `config`: JSON encoded config overrides applied for this call only.
8049    /// - `filter`: JSON encoded filter overrides applied for this call only.
8050    /// - `group`: Assign the request to a custom stats group.
8051    /// - `fs`: Remote name or path whose contents should be removed.
8052    pub async fn operations_delete<'a>(
8053        &'a self,
8054        async_: Option<bool>,
8055        config: Option<&'a str>,
8056        filter: Option<&'a str>,
8057        group: Option<&'a str>,
8058        fs: &'a str,
8059    ) -> Result<
8060        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8061        Error<types::RcError>,
8062    > {
8063        let url = format!("{}/operations/delete", self.baseurl,);
8064        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8065        header_map.append(
8066            ::reqwest::header::HeaderName::from_static("api-version"),
8067            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8068        );
8069        #[allow(unused_mut)]
8070        let mut request = self
8071            .client
8072            .post(url)
8073            .header(
8074                ::reqwest::header::ACCEPT,
8075                ::reqwest::header::HeaderValue::from_static("application/json"),
8076            )
8077            .query(&progenitor_client::QueryParam::new("_async", &async_))
8078            .query(&progenitor_client::QueryParam::new("_config", &config))
8079            .query(&progenitor_client::QueryParam::new("_filter", &filter))
8080            .query(&progenitor_client::QueryParam::new("_group", &group))
8081            .query(&progenitor_client::QueryParam::new("fs", &fs))
8082            .headers(header_map)
8083            .build()?;
8084        let info = OperationInfo {
8085            operation_id: "operations_delete",
8086        };
8087        self.pre(&mut request, &info).await?;
8088        let result = self.exec(request, &info).await;
8089        self.post(&result, &info).await?;
8090        let response = result?;
8091        match response.status().as_u16() {
8092            200u16 => ResponseValue::from_response(response).await,
8093            400u16..=499u16 => Err(Error::ErrorResponse(
8094                ResponseValue::from_response(response).await?,
8095            )),
8096            500u16..=599u16 => Err(Error::ErrorResponse(
8097                ResponseValue::from_response(response).await?,
8098            )),
8099            _ => Err(Error::UnexpectedResponse(response)),
8100        }
8101    }
8102
8103    ///Delete single file
8104    ///
8105    ///Removes a specific object from the remote.
8106    ///
8107    ///Sends a `POST` request to `/operations/deletefile`
8108    ///
8109    ///Arguments:
8110    /// - `async_`: Run the command asynchronously. Returns a job id
8111    ///   immediately.
8112    /// - `group`: Assign the request to a custom stats group.
8113    /// - `fs`: Remote name or path that contains the file to delete.
8114    /// - `remote`: Exact path to the file within `fs` that should be deleted.
8115    pub async fn operations_deletefile<'a>(
8116        &'a self,
8117        async_: Option<bool>,
8118        group: Option<&'a str>,
8119        fs: &'a str,
8120        remote: &'a str,
8121    ) -> Result<
8122        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8123        Error<types::RcError>,
8124    > {
8125        let url = format!("{}/operations/deletefile", self.baseurl,);
8126        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8127        header_map.append(
8128            ::reqwest::header::HeaderName::from_static("api-version"),
8129            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8130        );
8131        #[allow(unused_mut)]
8132        let mut request = self
8133            .client
8134            .post(url)
8135            .header(
8136                ::reqwest::header::ACCEPT,
8137                ::reqwest::header::HeaderValue::from_static("application/json"),
8138            )
8139            .query(&progenitor_client::QueryParam::new("_async", &async_))
8140            .query(&progenitor_client::QueryParam::new("_group", &group))
8141            .query(&progenitor_client::QueryParam::new("fs", &fs))
8142            .query(&progenitor_client::QueryParam::new("remote", &remote))
8143            .headers(header_map)
8144            .build()?;
8145        let info = OperationInfo {
8146            operation_id: "operations_deletefile",
8147        };
8148        self.pre(&mut request, &info).await?;
8149        let result = self.exec(request, &info).await;
8150        self.post(&result, &info).await?;
8151        let response = result?;
8152        match response.status().as_u16() {
8153            200u16 => ResponseValue::from_response(response).await,
8154            400u16..=499u16 => Err(Error::ErrorResponse(
8155                ResponseValue::from_response(response).await?,
8156            )),
8157            500u16..=599u16 => Err(Error::ErrorResponse(
8158                ResponseValue::from_response(response).await?,
8159            )),
8160            _ => Err(Error::UnexpectedResponse(response)),
8161        }
8162    }
8163
8164    ///Describe remote capabilities
8165    ///
8166    ///Returns backend features, hash support, metadata descriptions, and other
8167    /// info for the remote.
8168    ///
8169    ///Sends a `POST` request to `/operations/fsinfo`
8170    ///
8171    ///Arguments:
8172    /// - `async_`: Run the command asynchronously. Returns a job id
8173    ///   immediately.
8174    /// - `group`: Assign the request to a custom stats group.
8175    /// - `fs`: Remote name or path to inspect, e.g. `drive:`.
8176    pub async fn operations_fsinfo<'a>(
8177        &'a self,
8178        async_: Option<bool>,
8179        group: Option<&'a str>,
8180        fs: &'a str,
8181    ) -> Result<ResponseValue<types::OperationsFsinfoResponse>, Error<types::RcError>> {
8182        let url = format!("{}/operations/fsinfo", self.baseurl,);
8183        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8184        header_map.append(
8185            ::reqwest::header::HeaderName::from_static("api-version"),
8186            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8187        );
8188        #[allow(unused_mut)]
8189        let mut request = self
8190            .client
8191            .post(url)
8192            .header(
8193                ::reqwest::header::ACCEPT,
8194                ::reqwest::header::HeaderValue::from_static("application/json"),
8195            )
8196            .query(&progenitor_client::QueryParam::new("_async", &async_))
8197            .query(&progenitor_client::QueryParam::new("_group", &group))
8198            .query(&progenitor_client::QueryParam::new("fs", &fs))
8199            .headers(header_map)
8200            .build()?;
8201        let info = OperationInfo {
8202            operation_id: "operations_fsinfo",
8203        };
8204        self.pre(&mut request, &info).await?;
8205        let result = self.exec(request, &info).await;
8206        self.post(&result, &info).await?;
8207        let response = result?;
8208        match response.status().as_u16() {
8209            200u16 => ResponseValue::from_response(response).await,
8210            400u16..=499u16 => Err(Error::ErrorResponse(
8211                ResponseValue::from_response(response).await?,
8212            )),
8213            500u16..=599u16 => Err(Error::ErrorResponse(
8214                ResponseValue::from_response(response).await?,
8215            )),
8216            _ => Err(Error::UnexpectedResponse(response)),
8217        }
8218    }
8219
8220    ///Generate hash sums
8221    ///
8222    ///Produces a hash sum listing for files under the given path using the
8223    /// requested hash algorithm.
8224    ///
8225    ///Sends a `POST` request to `/operations/hashsum`
8226    ///
8227    ///Arguments:
8228    /// - `async_`: Run the command asynchronously. Returns a job id
8229    ///   immediately.
8230    /// - `group`: Assign the request to a custom stats group.
8231    /// - `base64`: Set to true to emit hash values in base64 rather than
8232    ///   hexadecimal.
8233    /// - `download`: Set to true to force reading the data instead of using
8234    ///   remote checksums.
8235    /// - `fs`: Remote name or path to hash, such as `drive:` or `/`.
8236    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
8237    ///   supported name.
8238    pub async fn operations_hashsum<'a>(
8239        &'a self,
8240        async_: Option<bool>,
8241        group: Option<&'a str>,
8242        base64: Option<bool>,
8243        download: Option<bool>,
8244        fs: &'a str,
8245        hash_type: &'a str,
8246    ) -> Result<ResponseValue<types::OperationsHashsumResponse>, Error<types::RcError>> {
8247        let url = format!("{}/operations/hashsum", self.baseurl,);
8248        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8249        header_map.append(
8250            ::reqwest::header::HeaderName::from_static("api-version"),
8251            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8252        );
8253        #[allow(unused_mut)]
8254        let mut request = self
8255            .client
8256            .post(url)
8257            .header(
8258                ::reqwest::header::ACCEPT,
8259                ::reqwest::header::HeaderValue::from_static("application/json"),
8260            )
8261            .query(&progenitor_client::QueryParam::new("_async", &async_))
8262            .query(&progenitor_client::QueryParam::new("_group", &group))
8263            .query(&progenitor_client::QueryParam::new("base64", &base64))
8264            .query(&progenitor_client::QueryParam::new("download", &download))
8265            .query(&progenitor_client::QueryParam::new("fs", &fs))
8266            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
8267            .headers(header_map)
8268            .build()?;
8269        let info = OperationInfo {
8270            operation_id: "operations_hashsum",
8271        };
8272        self.pre(&mut request, &info).await?;
8273        let result = self.exec(request, &info).await;
8274        self.post(&result, &info).await?;
8275        let response = result?;
8276        match response.status().as_u16() {
8277            200u16 => ResponseValue::from_response(response).await,
8278            400u16..=499u16 => Err(Error::ErrorResponse(
8279                ResponseValue::from_response(response).await?,
8280            )),
8281            500u16..=599u16 => Err(Error::ErrorResponse(
8282                ResponseValue::from_response(response).await?,
8283            )),
8284            _ => Err(Error::UnexpectedResponse(response)),
8285        }
8286    }
8287
8288    ///Move a single file
8289    ///
8290    ///Moves one object from a source remote and path to a destination remote
8291    /// and path.
8292    ///
8293    ///Sends a `POST` request to `/operations/movefile`
8294    ///
8295    ///Arguments:
8296    /// - `async_`: Run the command asynchronously. Returns a job id
8297    ///   immediately.
8298    /// - `group`: Assign the request to a custom stats group.
8299    /// - `dst_fs`: Destination remote name or path where the file will be
8300    ///   moved.
8301    /// - `dst_remote`: Destination path within `dstFs` for the moved object.
8302    /// - `src_fs`: Source remote name or path containing the file to move.
8303    /// - `src_remote`: Path to the source object within `srcFs`.
8304    pub async fn operations_movefile<'a>(
8305        &'a self,
8306        async_: Option<bool>,
8307        group: Option<&'a str>,
8308        dst_fs: &'a str,
8309        dst_remote: &'a str,
8310        src_fs: &'a str,
8311        src_remote: &'a str,
8312    ) -> Result<
8313        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8314        Error<types::RcError>,
8315    > {
8316        let url = format!("{}/operations/movefile", self.baseurl,);
8317        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8318        header_map.append(
8319            ::reqwest::header::HeaderName::from_static("api-version"),
8320            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8321        );
8322        #[allow(unused_mut)]
8323        let mut request = self
8324            .client
8325            .post(url)
8326            .header(
8327                ::reqwest::header::ACCEPT,
8328                ::reqwest::header::HeaderValue::from_static("application/json"),
8329            )
8330            .query(&progenitor_client::QueryParam::new("_async", &async_))
8331            .query(&progenitor_client::QueryParam::new("_group", &group))
8332            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
8333            .query(&progenitor_client::QueryParam::new(
8334                "dstRemote",
8335                &dst_remote,
8336            ))
8337            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
8338            .query(&progenitor_client::QueryParam::new(
8339                "srcRemote",
8340                &src_remote,
8341            ))
8342            .headers(header_map)
8343            .build()?;
8344        let info = OperationInfo {
8345            operation_id: "operations_movefile",
8346        };
8347        self.pre(&mut request, &info).await?;
8348        let result = self.exec(request, &info).await;
8349        self.post(&result, &info).await?;
8350        let response = result?;
8351        match response.status().as_u16() {
8352            200u16 => ResponseValue::from_response(response).await,
8353            400u16..=499u16 => Err(Error::ErrorResponse(
8354                ResponseValue::from_response(response).await?,
8355            )),
8356            500u16..=599u16 => Err(Error::ErrorResponse(
8357                ResponseValue::from_response(response).await?,
8358            )),
8359            _ => Err(Error::UnexpectedResponse(response)),
8360        }
8361    }
8362
8363    ///Create or remove public link
8364    ///
8365    ///Creates a share URL for an object or removes an existing link when
8366    /// `unlink=true`.
8367    ///
8368    ///Sends a `POST` request to `/operations/publiclink`
8369    ///
8370    ///Arguments:
8371    /// - `async_`: Run the command asynchronously. Returns a job id
8372    ///   immediately.
8373    /// - `group`: Assign the request to a custom stats group.
8374    /// - `expire`: Optional expiration time for the public link, formatted as
8375    ///   supported by the backend.
8376    /// - `fs`: Remote name or path hosting the object for which to manage a
8377    ///   public link.
8378    /// - `remote`: Path within `fs` to the object for which to create or remove
8379    ///   a public link.
8380    /// - `unlink`: Set to true to remove an existing public link instead of
8381    ///   creating one.
8382    pub async fn operations_publiclink<'a>(
8383        &'a self,
8384        async_: Option<bool>,
8385        group: Option<&'a str>,
8386        expire: Option<&'a str>,
8387        fs: &'a str,
8388        remote: &'a str,
8389        unlink: Option<bool>,
8390    ) -> Result<ResponseValue<types::OperationsPubliclinkResponse>, Error<types::RcError>> {
8391        let url = format!("{}/operations/publiclink", self.baseurl,);
8392        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8393        header_map.append(
8394            ::reqwest::header::HeaderName::from_static("api-version"),
8395            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8396        );
8397        #[allow(unused_mut)]
8398        let mut request = self
8399            .client
8400            .post(url)
8401            .header(
8402                ::reqwest::header::ACCEPT,
8403                ::reqwest::header::HeaderValue::from_static("application/json"),
8404            )
8405            .query(&progenitor_client::QueryParam::new("_async", &async_))
8406            .query(&progenitor_client::QueryParam::new("_group", &group))
8407            .query(&progenitor_client::QueryParam::new("expire", &expire))
8408            .query(&progenitor_client::QueryParam::new("fs", &fs))
8409            .query(&progenitor_client::QueryParam::new("remote", &remote))
8410            .query(&progenitor_client::QueryParam::new("unlink", &unlink))
8411            .headers(header_map)
8412            .build()?;
8413        let info = OperationInfo {
8414            operation_id: "operations_publiclink",
8415        };
8416        self.pre(&mut request, &info).await?;
8417        let result = self.exec(request, &info).await;
8418        self.post(&result, &info).await?;
8419        let response = result?;
8420        match response.status().as_u16() {
8421            200u16 => ResponseValue::from_response(response).await,
8422            400u16..=499u16 => Err(Error::ErrorResponse(
8423                ResponseValue::from_response(response).await?,
8424            )),
8425            500u16..=599u16 => Err(Error::ErrorResponse(
8426                ResponseValue::from_response(response).await?,
8427            )),
8428            _ => Err(Error::UnexpectedResponse(response)),
8429        }
8430    }
8431
8432    ///Remove empty directories
8433    ///
8434    ///Deletes empty subdirectories beneath the specified path, optionally
8435    /// leaving the root.
8436    ///
8437    ///Sends a `POST` request to `/operations/rmdirs`
8438    ///
8439    ///Arguments:
8440    /// - `async_`: Run the command asynchronously. Returns a job id
8441    ///   immediately.
8442    /// - `group`: Assign the request to a custom stats group.
8443    /// - `fs`: Remote name or path to scan for empty directories.
8444    /// - `leave_root`: Set to true to preserve the top-level directory even if
8445    ///   empty.
8446    /// - `remote`: Path within `fs` whose empty subdirectories should be
8447    ///   removed.
8448    pub async fn operations_rmdirs<'a>(
8449        &'a self,
8450        async_: Option<bool>,
8451        group: Option<&'a str>,
8452        fs: &'a str,
8453        leave_root: Option<bool>,
8454        remote: &'a str,
8455    ) -> Result<
8456        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8457        Error<types::RcError>,
8458    > {
8459        let url = format!("{}/operations/rmdirs", self.baseurl,);
8460        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8461        header_map.append(
8462            ::reqwest::header::HeaderName::from_static("api-version"),
8463            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8464        );
8465        #[allow(unused_mut)]
8466        let mut request = self
8467            .client
8468            .post(url)
8469            .header(
8470                ::reqwest::header::ACCEPT,
8471                ::reqwest::header::HeaderValue::from_static("application/json"),
8472            )
8473            .query(&progenitor_client::QueryParam::new("_async", &async_))
8474            .query(&progenitor_client::QueryParam::new("_group", &group))
8475            .query(&progenitor_client::QueryParam::new("fs", &fs))
8476            .query(&progenitor_client::QueryParam::new(
8477                "leaveRoot",
8478                &leave_root,
8479            ))
8480            .query(&progenitor_client::QueryParam::new("remote", &remote))
8481            .headers(header_map)
8482            .build()?;
8483        let info = OperationInfo {
8484            operation_id: "operations_rmdirs",
8485        };
8486        self.pre(&mut request, &info).await?;
8487        let result = self.exec(request, &info).await;
8488        self.post(&result, &info).await?;
8489        let response = result?;
8490        match response.status().as_u16() {
8491            200u16 => ResponseValue::from_response(response).await,
8492            400u16..=499u16 => Err(Error::ErrorResponse(
8493                ResponseValue::from_response(response).await?,
8494            )),
8495            500u16..=599u16 => Err(Error::ErrorResponse(
8496                ResponseValue::from_response(response).await?,
8497            )),
8498            _ => Err(Error::UnexpectedResponse(response)),
8499        }
8500    }
8501
8502    ///Change storage tier
8503    ///
8504    ///Updates the storage class or tier for every object in the specified
8505    /// remote path.
8506    ///
8507    ///Sends a `POST` request to `/operations/settier`
8508    ///
8509    ///Arguments:
8510    /// - `async_`: Run the command asynchronously. Returns a job id
8511    ///   immediately.
8512    /// - `group`: Assign the request to a custom stats group.
8513    /// - `fs`: Remote name or path whose storage class tier should be changed.
8514    pub async fn operations_settier<'a>(
8515        &'a self,
8516        async_: Option<bool>,
8517        group: Option<&'a str>,
8518        fs: &'a str,
8519    ) -> Result<
8520        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8521        Error<types::RcError>,
8522    > {
8523        let url = format!("{}/operations/settier", self.baseurl,);
8524        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8525        header_map.append(
8526            ::reqwest::header::HeaderName::from_static("api-version"),
8527            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8528        );
8529        #[allow(unused_mut)]
8530        let mut request = self
8531            .client
8532            .post(url)
8533            .header(
8534                ::reqwest::header::ACCEPT,
8535                ::reqwest::header::HeaderValue::from_static("application/json"),
8536            )
8537            .query(&progenitor_client::QueryParam::new("_async", &async_))
8538            .query(&progenitor_client::QueryParam::new("_group", &group))
8539            .query(&progenitor_client::QueryParam::new("fs", &fs))
8540            .headers(header_map)
8541            .build()?;
8542        let info = OperationInfo {
8543            operation_id: "operations_settier",
8544        };
8545        self.pre(&mut request, &info).await?;
8546        let result = self.exec(request, &info).await;
8547        self.post(&result, &info).await?;
8548        let response = result?;
8549        match response.status().as_u16() {
8550            200u16 => ResponseValue::from_response(response).await,
8551            400u16..=499u16 => Err(Error::ErrorResponse(
8552                ResponseValue::from_response(response).await?,
8553            )),
8554            500u16..=599u16 => Err(Error::ErrorResponse(
8555                ResponseValue::from_response(response).await?,
8556            )),
8557            _ => Err(Error::UnexpectedResponse(response)),
8558        }
8559    }
8560
8561    ///Change file storage tier
8562    ///
8563    ///Updates the storage class or tier for a single object.
8564    ///
8565    ///Sends a `POST` request to `/operations/settierfile`
8566    ///
8567    ///Arguments:
8568    /// - `async_`: Run the command asynchronously. Returns a job id
8569    ///   immediately.
8570    /// - `group`: Assign the request to a custom stats group.
8571    /// - `fs`: Remote name or path that contains the object whose tier should
8572    ///   change.
8573    /// - `remote`: Path within `fs` to the object whose storage class tier
8574    ///   should be updated.
8575    pub async fn operations_settierfile<'a>(
8576        &'a self,
8577        async_: Option<bool>,
8578        group: Option<&'a str>,
8579        fs: &'a str,
8580        remote: &'a str,
8581    ) -> Result<
8582        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8583        Error<types::RcError>,
8584    > {
8585        let url = format!("{}/operations/settierfile", self.baseurl,);
8586        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8587        header_map.append(
8588            ::reqwest::header::HeaderName::from_static("api-version"),
8589            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8590        );
8591        #[allow(unused_mut)]
8592        let mut request = self
8593            .client
8594            .post(url)
8595            .header(
8596                ::reqwest::header::ACCEPT,
8597                ::reqwest::header::HeaderValue::from_static("application/json"),
8598            )
8599            .query(&progenitor_client::QueryParam::new("_async", &async_))
8600            .query(&progenitor_client::QueryParam::new("_group", &group))
8601            .query(&progenitor_client::QueryParam::new("fs", &fs))
8602            .query(&progenitor_client::QueryParam::new("remote", &remote))
8603            .headers(header_map)
8604            .build()?;
8605        let info = OperationInfo {
8606            operation_id: "operations_settierfile",
8607        };
8608        self.pre(&mut request, &info).await?;
8609        let result = self.exec(request, &info).await;
8610        self.post(&result, &info).await?;
8611        let response = result?;
8612        match response.status().as_u16() {
8613            200u16 => ResponseValue::from_response(response).await,
8614            400u16..=499u16 => Err(Error::ErrorResponse(
8615                ResponseValue::from_response(response).await?,
8616            )),
8617            500u16..=599u16 => Err(Error::ErrorResponse(
8618                ResponseValue::from_response(response).await?,
8619            )),
8620            _ => Err(Error::UnexpectedResponse(response)),
8621        }
8622    }
8623
8624    ///Count remote size
8625    ///
8626    ///Reports total size, file count, and number of objects without size
8627    /// metadata.
8628    ///
8629    ///Sends a `POST` request to `/operations/size`
8630    ///
8631    ///Arguments:
8632    /// - `async_`: Run the command asynchronously. Returns a job id
8633    ///   immediately.
8634    /// - `group`: Assign the request to a custom stats group.
8635    /// - `fs`: Remote name or path to measure aggregate size information for.
8636    pub async fn operations_size<'a>(
8637        &'a self,
8638        async_: Option<bool>,
8639        group: Option<&'a str>,
8640        fs: &'a str,
8641    ) -> Result<ResponseValue<types::OperationsSizeResponse>, Error<types::RcError>> {
8642        let url = format!("{}/operations/size", self.baseurl,);
8643        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8644        header_map.append(
8645            ::reqwest::header::HeaderName::from_static("api-version"),
8646            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8647        );
8648        #[allow(unused_mut)]
8649        let mut request = self
8650            .client
8651            .post(url)
8652            .header(
8653                ::reqwest::header::ACCEPT,
8654                ::reqwest::header::HeaderValue::from_static("application/json"),
8655            )
8656            .query(&progenitor_client::QueryParam::new("_async", &async_))
8657            .query(&progenitor_client::QueryParam::new("_group", &group))
8658            .query(&progenitor_client::QueryParam::new("fs", &fs))
8659            .headers(header_map)
8660            .build()?;
8661        let info = OperationInfo {
8662            operation_id: "operations_size",
8663        };
8664        self.pre(&mut request, &info).await?;
8665        let result = self.exec(request, &info).await;
8666        self.post(&result, &info).await?;
8667        let response = result?;
8668        match response.status().as_u16() {
8669            200u16 => ResponseValue::from_response(response).await,
8670            400u16..=499u16 => Err(Error::ErrorResponse(
8671                ResponseValue::from_response(response).await?,
8672            )),
8673            500u16..=599u16 => Err(Error::ErrorResponse(
8674                ResponseValue::from_response(response).await?,
8675            )),
8676            _ => Err(Error::UnexpectedResponse(response)),
8677        }
8678    }
8679
8680    ///Get or update bandwidth limits
8681    ///
8682    ///Reads the current bandwidth limit or applies a new schedule string, just
8683    /// like `rclone rc core/bwlimit`.
8684    ///
8685    ///Sends a `POST` request to `/core/bwlimit`
8686    ///
8687    ///Arguments:
8688    /// - `async_`: Run the command asynchronously. Returns a job id
8689    ///   immediately.
8690    /// - `group`: Assign the request to a custom stats group.
8691    /// - `rate`: Bandwidth limit to apply, for example `off`, `5M`, or a
8692    ///   schedule string.
8693    pub async fn core_bwlimit<'a>(
8694        &'a self,
8695        async_: Option<bool>,
8696        group: Option<&'a str>,
8697        rate: Option<&'a str>,
8698    ) -> Result<ResponseValue<types::CoreBwlimitResponse>, Error<types::RcError>> {
8699        let url = format!("{}/core/bwlimit", self.baseurl,);
8700        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8701        header_map.append(
8702            ::reqwest::header::HeaderName::from_static("api-version"),
8703            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8704        );
8705        #[allow(unused_mut)]
8706        let mut request = self
8707            .client
8708            .post(url)
8709            .header(
8710                ::reqwest::header::ACCEPT,
8711                ::reqwest::header::HeaderValue::from_static("application/json"),
8712            )
8713            .query(&progenitor_client::QueryParam::new("_async", &async_))
8714            .query(&progenitor_client::QueryParam::new("_group", &group))
8715            .query(&progenitor_client::QueryParam::new("rate", &rate))
8716            .headers(header_map)
8717            .build()?;
8718        let info = OperationInfo {
8719            operation_id: "core_bwlimit",
8720        };
8721        self.pre(&mut request, &info).await?;
8722        let result = self.exec(request, &info).await;
8723        self.post(&result, &info).await?;
8724        let response = result?;
8725        match response.status().as_u16() {
8726            200u16 => ResponseValue::from_response(response).await,
8727            400u16..=499u16 => Err(Error::ErrorResponse(
8728                ResponseValue::from_response(response).await?,
8729            )),
8730            500u16..=599u16 => Err(Error::ErrorResponse(
8731                ResponseValue::from_response(response).await?,
8732            )),
8733            _ => Err(Error::UnexpectedResponse(response)),
8734        }
8735    }
8736
8737    ///Run an rclone command
8738    ///
8739    ///Executes a standard rclone CLI command remotely and streams or returns
8740    /// its output.
8741    ///
8742    ///Sends a `POST` request to `/core/command`
8743    ///
8744    ///Arguments:
8745    /// - `async_`: Run the command asynchronously. Returns a job id
8746    ///   immediately.
8747    /// - `group`: Assign the request to a custom stats group.
8748    /// - `arg`: Optional positional arguments for the command. Repeat to supply
8749    ///   multiple values.
8750    /// - `command`: Name of the rclone command to execute, for example `ls` or
8751    ///   `lsf`.
8752    /// - `opt`: Optional command options encoded as a JSON string.
8753    /// - `return_type`: Controls how output is returned; accepts
8754    ///   `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
8755    ///   `STREAM_ONLY_STDERR`.
8756    pub async fn core_command<'a>(
8757        &'a self,
8758        async_: Option<bool>,
8759        group: Option<&'a str>,
8760        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
8761        command: &'a str,
8762        opt: Option<&'a str>,
8763        return_type: Option<&'a str>,
8764    ) -> Result<ResponseValue<types::CoreCommandResponse>, Error<types::RcError>> {
8765        let url = format!("{}/core/command", self.baseurl,);
8766        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8767        header_map.append(
8768            ::reqwest::header::HeaderName::from_static("api-version"),
8769            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8770        );
8771        #[allow(unused_mut)]
8772        let mut request = self
8773            .client
8774            .post(url)
8775            .header(
8776                ::reqwest::header::ACCEPT,
8777                ::reqwest::header::HeaderValue::from_static("application/json"),
8778            )
8779            .query(&progenitor_client::QueryParam::new("_async", &async_))
8780            .query(&progenitor_client::QueryParam::new("_group", &group))
8781            .query(&progenitor_client::QueryParam::new("arg", &arg))
8782            .query(&progenitor_client::QueryParam::new("command", &command))
8783            .query(&progenitor_client::QueryParam::new("opt", &opt))
8784            .query(&progenitor_client::QueryParam::new(
8785                "returnType",
8786                &return_type,
8787            ))
8788            .headers(header_map)
8789            .build()?;
8790        let info = OperationInfo {
8791            operation_id: "core_command",
8792        };
8793        self.pre(&mut request, &info).await?;
8794        let result = self.exec(request, &info).await;
8795        self.post(&result, &info).await?;
8796        let response = result?;
8797        match response.status().as_u16() {
8798            200u16 => ResponseValue::from_response(response).await,
8799            400u16..=499u16 => Err(Error::ErrorResponse(
8800                ResponseValue::from_response(response).await?,
8801            )),
8802            500u16..=599u16 => Err(Error::ErrorResponse(
8803                ResponseValue::from_response(response).await?,
8804            )),
8805            _ => Err(Error::UnexpectedResponse(response)),
8806        }
8807    }
8808
8809    ///Report disk usage
8810    ///
8811    ///Returns disk usage statistics for the supplied local directory (defaults
8812    /// to the cache dir).
8813    ///
8814    ///Sends a `POST` request to `/core/du`
8815    ///
8816    ///Arguments:
8817    /// - `async_`: Run the command asynchronously. Returns a job id
8818    ///   immediately.
8819    /// - `group`: Assign the request to a custom stats group.
8820    /// - `dir`: Local directory path to report disk usage for. Defaults to the
8821    ///   rclone cache directory when omitted.
8822    pub async fn core_du<'a>(
8823        &'a self,
8824        async_: Option<bool>,
8825        group: Option<&'a str>,
8826        dir: Option<&'a str>,
8827    ) -> Result<ResponseValue<types::CoreDuResponse>, Error<types::RcError>> {
8828        let url = format!("{}/core/du", self.baseurl,);
8829        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8830        header_map.append(
8831            ::reqwest::header::HeaderName::from_static("api-version"),
8832            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8833        );
8834        #[allow(unused_mut)]
8835        let mut request = self
8836            .client
8837            .post(url)
8838            .header(
8839                ::reqwest::header::ACCEPT,
8840                ::reqwest::header::HeaderValue::from_static("application/json"),
8841            )
8842            .query(&progenitor_client::QueryParam::new("_async", &async_))
8843            .query(&progenitor_client::QueryParam::new("_group", &group))
8844            .query(&progenitor_client::QueryParam::new("dir", &dir))
8845            .headers(header_map)
8846            .build()?;
8847        let info = OperationInfo {
8848            operation_id: "core_du",
8849        };
8850        self.pre(&mut request, &info).await?;
8851        let result = self.exec(request, &info).await;
8852        self.post(&result, &info).await?;
8853        let response = result?;
8854        match response.status().as_u16() {
8855            200u16 => ResponseValue::from_response(response).await,
8856            400u16..=499u16 => Err(Error::ErrorResponse(
8857                ResponseValue::from_response(response).await?,
8858            )),
8859            500u16..=599u16 => Err(Error::ErrorResponse(
8860                ResponseValue::from_response(response).await?,
8861            )),
8862            _ => Err(Error::UnexpectedResponse(response)),
8863        }
8864    }
8865
8866    ///Force garbage collection
8867    ///
8868    ///Triggers Go's garbage collector to release unused memory.
8869    ///
8870    ///Sends a `POST` request to `/core/gc`
8871    ///
8872    ///Arguments:
8873    /// - `async_`: Run the command asynchronously. Returns a job id
8874    ///   immediately.
8875    /// - `group`: Assign the request to a custom stats group.
8876    pub async fn core_gc<'a>(
8877        &'a self,
8878        async_: Option<bool>,
8879        group: Option<&'a str>,
8880    ) -> Result<
8881        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8882        Error<types::RcError>,
8883    > {
8884        let url = format!("{}/core/gc", self.baseurl,);
8885        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8886        header_map.append(
8887            ::reqwest::header::HeaderName::from_static("api-version"),
8888            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8889        );
8890        #[allow(unused_mut)]
8891        let mut request = self
8892            .client
8893            .post(url)
8894            .header(
8895                ::reqwest::header::ACCEPT,
8896                ::reqwest::header::HeaderValue::from_static("application/json"),
8897            )
8898            .query(&progenitor_client::QueryParam::new("_async", &async_))
8899            .query(&progenitor_client::QueryParam::new("_group", &group))
8900            .headers(header_map)
8901            .build()?;
8902        let info = OperationInfo {
8903            operation_id: "core_gc",
8904        };
8905        self.pre(&mut request, &info).await?;
8906        let result = self.exec(request, &info).await;
8907        self.post(&result, &info).await?;
8908        let response = result?;
8909        match response.status().as_u16() {
8910            200u16 => ResponseValue::from_response(response).await,
8911            400u16..=499u16 => Err(Error::ErrorResponse(
8912                ResponseValue::from_response(response).await?,
8913            )),
8914            500u16..=599u16 => Err(Error::ErrorResponse(
8915                ResponseValue::from_response(response).await?,
8916            )),
8917            _ => Err(Error::UnexpectedResponse(response)),
8918        }
8919    }
8920
8921    ///List stats groups
8922    ///
8923    ///Lists stats groups currently tracked by rclone.
8924    ///
8925    ///Sends a `POST` request to `/core/group-list`
8926    ///
8927    ///Arguments:
8928    /// - `async_`: Run the command asynchronously. Returns a job id
8929    ///   immediately.
8930    /// - `group`: Assign the request to a custom stats group.
8931    pub async fn core_group_list<'a>(
8932        &'a self,
8933        async_: Option<bool>,
8934        group: Option<&'a str>,
8935    ) -> Result<ResponseValue<types::CoreGroupListResponse>, Error<types::RcError>> {
8936        let url = format!("{}/core/group-list", self.baseurl,);
8937        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8938        header_map.append(
8939            ::reqwest::header::HeaderName::from_static("api-version"),
8940            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8941        );
8942        #[allow(unused_mut)]
8943        let mut request = self
8944            .client
8945            .post(url)
8946            .header(
8947                ::reqwest::header::ACCEPT,
8948                ::reqwest::header::HeaderValue::from_static("application/json"),
8949            )
8950            .query(&progenitor_client::QueryParam::new("_async", &async_))
8951            .query(&progenitor_client::QueryParam::new("_group", &group))
8952            .headers(header_map)
8953            .build()?;
8954        let info = OperationInfo {
8955            operation_id: "core_group_list",
8956        };
8957        self.pre(&mut request, &info).await?;
8958        let result = self.exec(request, &info).await;
8959        self.post(&result, &info).await?;
8960        let response = result?;
8961        match response.status().as_u16() {
8962            200u16 => ResponseValue::from_response(response).await,
8963            400u16..=499u16 => Err(Error::ErrorResponse(
8964                ResponseValue::from_response(response).await?,
8965            )),
8966            500u16..=599u16 => Err(Error::ErrorResponse(
8967                ResponseValue::from_response(response).await?,
8968            )),
8969            _ => Err(Error::UnexpectedResponse(response)),
8970        }
8971    }
8972
8973    ///Fetch runtime memory stats
8974    ///
8975    ///Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
8976    ///
8977    ///Sends a `POST` request to `/core/memstats`
8978    ///
8979    ///Arguments:
8980    /// - `async_`: Run the command asynchronously. Returns a job id
8981    ///   immediately.
8982    /// - `group`: Assign the request to a custom stats group.
8983    pub async fn core_memstats<'a>(
8984        &'a self,
8985        async_: Option<bool>,
8986        group: Option<&'a str>,
8987    ) -> Result<
8988        ResponseValue<::std::collections::HashMap<::std::string::String, f64>>,
8989        Error<types::RcError>,
8990    > {
8991        let url = format!("{}/core/memstats", self.baseurl,);
8992        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8993        header_map.append(
8994            ::reqwest::header::HeaderName::from_static("api-version"),
8995            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8996        );
8997        #[allow(unused_mut)]
8998        let mut request = self
8999            .client
9000            .post(url)
9001            .header(
9002                ::reqwest::header::ACCEPT,
9003                ::reqwest::header::HeaderValue::from_static("application/json"),
9004            )
9005            .query(&progenitor_client::QueryParam::new("_async", &async_))
9006            .query(&progenitor_client::QueryParam::new("_group", &group))
9007            .headers(header_map)
9008            .build()?;
9009        let info = OperationInfo {
9010            operation_id: "core_memstats",
9011        };
9012        self.pre(&mut request, &info).await?;
9013        let result = self.exec(request, &info).await;
9014        self.post(&result, &info).await?;
9015        let response = result?;
9016        match response.status().as_u16() {
9017            200u16 => ResponseValue::from_response(response).await,
9018            400u16..=499u16 => Err(Error::ErrorResponse(
9019                ResponseValue::from_response(response).await?,
9020            )),
9021            500u16..=599u16 => Err(Error::ErrorResponse(
9022                ResponseValue::from_response(response).await?,
9023            )),
9024            _ => Err(Error::UnexpectedResponse(response)),
9025        }
9026    }
9027
9028    ///Obscure a clear string
9029    ///
9030    ///Obscures a plain-text secret for inclusion in `rclone.conf`.
9031    ///
9032    ///Sends a `POST` request to `/core/obscure`
9033    ///
9034    ///Arguments:
9035    /// - `async_`: Run the command asynchronously. Returns a job id
9036    ///   immediately.
9037    /// - `group`: Assign the request to a custom stats group.
9038    /// - `clear`: Plain-text string to obscure for storage in the config file.
9039    pub async fn core_obscure<'a>(
9040        &'a self,
9041        async_: Option<bool>,
9042        group: Option<&'a str>,
9043        clear: &'a str,
9044    ) -> Result<ResponseValue<types::CoreObscureResponse>, Error<types::RcError>> {
9045        let url = format!("{}/core/obscure", self.baseurl,);
9046        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9047        header_map.append(
9048            ::reqwest::header::HeaderName::from_static("api-version"),
9049            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9050        );
9051        #[allow(unused_mut)]
9052        let mut request = self
9053            .client
9054            .post(url)
9055            .header(
9056                ::reqwest::header::ACCEPT,
9057                ::reqwest::header::HeaderValue::from_static("application/json"),
9058            )
9059            .query(&progenitor_client::QueryParam::new("_async", &async_))
9060            .query(&progenitor_client::QueryParam::new("_group", &group))
9061            .query(&progenitor_client::QueryParam::new("clear", &clear))
9062            .headers(header_map)
9063            .build()?;
9064        let info = OperationInfo {
9065            operation_id: "core_obscure",
9066        };
9067        self.pre(&mut request, &info).await?;
9068        let result = self.exec(request, &info).await;
9069        self.post(&result, &info).await?;
9070        let response = result?;
9071        match response.status().as_u16() {
9072            200u16 => ResponseValue::from_response(response).await,
9073            400u16..=499u16 => Err(Error::ErrorResponse(
9074                ResponseValue::from_response(response).await?,
9075            )),
9076            500u16..=599u16 => Err(Error::ErrorResponse(
9077                ResponseValue::from_response(response).await?,
9078            )),
9079            _ => Err(Error::UnexpectedResponse(response)),
9080        }
9081    }
9082
9083    ///Return rclone PID
9084    ///
9085    ///Returns the process ID of the running rclone instance.
9086    ///
9087    ///Sends a `POST` request to `/core/pid`
9088    ///
9089    ///Arguments:
9090    /// - `async_`: Run the command asynchronously. Returns a job id
9091    ///   immediately.
9092    /// - `group`: Assign the request to a custom stats group.
9093    pub async fn core_pid<'a>(
9094        &'a self,
9095        async_: Option<bool>,
9096        group: Option<&'a str>,
9097    ) -> Result<ResponseValue<types::CorePidResponse>, Error<types::RcError>> {
9098        let url = format!("{}/core/pid", self.baseurl,);
9099        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9100        header_map.append(
9101            ::reqwest::header::HeaderName::from_static("api-version"),
9102            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9103        );
9104        #[allow(unused_mut)]
9105        let mut request = self
9106            .client
9107            .post(url)
9108            .header(
9109                ::reqwest::header::ACCEPT,
9110                ::reqwest::header::HeaderValue::from_static("application/json"),
9111            )
9112            .query(&progenitor_client::QueryParam::new("_async", &async_))
9113            .query(&progenitor_client::QueryParam::new("_group", &group))
9114            .headers(header_map)
9115            .build()?;
9116        let info = OperationInfo {
9117            operation_id: "core_pid",
9118        };
9119        self.pre(&mut request, &info).await?;
9120        let result = self.exec(request, &info).await;
9121        self.post(&result, &info).await?;
9122        let response = result?;
9123        match response.status().as_u16() {
9124            200u16 => ResponseValue::from_response(response).await,
9125            400u16..=499u16 => Err(Error::ErrorResponse(
9126                ResponseValue::from_response(response).await?,
9127            )),
9128            500u16..=599u16 => Err(Error::ErrorResponse(
9129                ResponseValue::from_response(response).await?,
9130            )),
9131            _ => Err(Error::UnexpectedResponse(response)),
9132        }
9133    }
9134
9135    ///Terminate rclone
9136    ///
9137    ///Stops the rclone process, optionally supplying an exit code.
9138    ///
9139    ///Sends a `POST` request to `/core/quit`
9140    ///
9141    ///Arguments:
9142    /// - `async_`: Run the command asynchronously. Returns a job id
9143    ///   immediately.
9144    /// - `group`: Assign the request to a custom stats group.
9145    /// - `exit_code`: Optional exit code to use when terminating the rclone
9146    ///   process.
9147    pub async fn core_quit<'a>(
9148        &'a self,
9149        async_: Option<bool>,
9150        group: Option<&'a str>,
9151        exit_code: Option<i64>,
9152    ) -> Result<
9153        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9154        Error<types::RcError>,
9155    > {
9156        let url = format!("{}/core/quit", self.baseurl,);
9157        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9158        header_map.append(
9159            ::reqwest::header::HeaderName::from_static("api-version"),
9160            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9161        );
9162        #[allow(unused_mut)]
9163        let mut request = self
9164            .client
9165            .post(url)
9166            .header(
9167                ::reqwest::header::ACCEPT,
9168                ::reqwest::header::HeaderValue::from_static("application/json"),
9169            )
9170            .query(&progenitor_client::QueryParam::new("_async", &async_))
9171            .query(&progenitor_client::QueryParam::new("_group", &group))
9172            .query(&progenitor_client::QueryParam::new("exitCode", &exit_code))
9173            .headers(header_map)
9174            .build()?;
9175        let info = OperationInfo {
9176            operation_id: "core_quit",
9177        };
9178        self.pre(&mut request, &info).await?;
9179        let result = self.exec(request, &info).await;
9180        self.post(&result, &info).await?;
9181        let response = result?;
9182        match response.status().as_u16() {
9183            200u16 => ResponseValue::from_response(response).await,
9184            400u16..=499u16 => Err(Error::ErrorResponse(
9185                ResponseValue::from_response(response).await?,
9186            )),
9187            500u16..=599u16 => Err(Error::ErrorResponse(
9188                ResponseValue::from_response(response).await?,
9189            )),
9190            _ => Err(Error::UnexpectedResponse(response)),
9191        }
9192    }
9193
9194    ///Delete stats group
9195    ///
9196    ///Deletes the counters associated with a specific stats group.
9197    ///
9198    ///Sends a `POST` request to `/core/stats-delete`
9199    ///
9200    ///Arguments:
9201    /// - `async_`: Run the command asynchronously. Returns a job id
9202    ///   immediately.
9203    /// - `group`: Assign the request to a custom stats group.
9204    /// - `group`: Stats group identifier to remove.
9205    pub async fn core_stats_delete<'a>(
9206        &'a self,
9207        async_: Option<bool>,
9208        _group: Option<&'a str>,
9209        group: &'a str
9210    ) -> Result<
9211        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9212        Error<types::RcError>,
9213    > {
9214        let url = format!("{}/core/stats-delete", self.baseurl,);
9215        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9216        header_map.append(
9217            ::reqwest::header::HeaderName::from_static("api-version"),
9218            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9219        );
9220        #[allow(unused_mut)]
9221        let mut request = self
9222            .client
9223            .post(url)
9224            .header(
9225                ::reqwest::header::ACCEPT,
9226                ::reqwest::header::HeaderValue::from_static("application/json"),
9227            )
9228            .query(&progenitor_client::QueryParam::new("_async", &async_))
9229            .query(&progenitor_client::QueryParam::new("_group", &group))
9230            .query(&progenitor_client::QueryParam::new("group", &group))
9231            .headers(header_map)
9232            .build()?;
9233        let info = OperationInfo {
9234            operation_id: "core_stats_delete",
9235        };
9236        self.pre(&mut request, &info).await?;
9237        let result = self.exec(request, &info).await;
9238        self.post(&result, &info).await?;
9239        let response = result?;
9240        match response.status().as_u16() {
9241            200u16 => ResponseValue::from_response(response).await,
9242            400u16..=499u16 => Err(Error::ErrorResponse(
9243                ResponseValue::from_response(response).await?,
9244            )),
9245            500u16..=599u16 => Err(Error::ErrorResponse(
9246                ResponseValue::from_response(response).await?,
9247            )),
9248            _ => Err(Error::UnexpectedResponse(response)),
9249        }
9250    }
9251
9252    ///Reset stats counters
9253    ///
9254    ///Clears counters, errors, and finished transfers for the provided stats
9255    /// group or all groups.
9256    ///
9257    ///Sends a `POST` request to `/core/stats-reset`
9258    ///
9259    ///Arguments:
9260    /// - `async_`: Run the command asynchronously. Returns a job id
9261    ///   immediately.
9262    /// - `group`: Assign the request to a custom stats group.
9263    /// - `group`: Stats group identifier whose counters should be reset. Leave
9264    ///   unset to reset all groups.
9265    pub async fn core_stats_reset<'a>(
9266        &'a self,
9267        async_: Option<bool>,
9268        _group: Option<&'a str>,
9269        group: Option<&'a str>
9270    ) -> Result<
9271        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9272        Error<types::RcError>,
9273    > {
9274        let url = format!("{}/core/stats-reset", self.baseurl,);
9275        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9276        header_map.append(
9277            ::reqwest::header::HeaderName::from_static("api-version"),
9278            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9279        );
9280        #[allow(unused_mut)]
9281        let mut request = self
9282            .client
9283            .post(url)
9284            .header(
9285                ::reqwest::header::ACCEPT,
9286                ::reqwest::header::HeaderValue::from_static("application/json"),
9287            )
9288            .query(&progenitor_client::QueryParam::new("_async", &async_))
9289            .query(&progenitor_client::QueryParam::new("_group", &group))
9290            .query(&progenitor_client::QueryParam::new("group", &group))
9291            .headers(header_map)
9292            .build()?;
9293        let info = OperationInfo {
9294            operation_id: "core_stats_reset",
9295        };
9296        self.pre(&mut request, &info).await?;
9297        let result = self.exec(request, &info).await;
9298        self.post(&result, &info).await?;
9299        let response = result?;
9300        match response.status().as_u16() {
9301            200u16 => ResponseValue::from_response(response).await,
9302            400u16..=499u16 => Err(Error::ErrorResponse(
9303                ResponseValue::from_response(response).await?,
9304            )),
9305            500u16..=599u16 => Err(Error::ErrorResponse(
9306                ResponseValue::from_response(response).await?,
9307            )),
9308            _ => Err(Error::UnexpectedResponse(response)),
9309        }
9310    }
9311
9312    ///List completed transfers
9313    ///
9314    ///Returns up to 100 recently completed transfers for the requested stats
9315    /// group.
9316    ///
9317    ///Sends a `POST` request to `/core/transferred`
9318    ///
9319    ///Arguments:
9320    /// - `async_`: Run the command asynchronously. Returns a job id
9321    ///   immediately.
9322    /// - `group`: Assign the request to a custom stats group.
9323    /// - `group`: Stats group identifier to filter the completed transfer list.
9324    ///   Leave unset for all groups.
9325    pub async fn core_transferred<'a>(
9326        &'a self,
9327        async_: Option<bool>,
9328        _group: Option<&'a str>,
9329        group: Option<&'a str>
9330    ) -> Result<ResponseValue<types::CoreTransferredResponse>, Error<types::RcError>> {
9331        let url = format!("{}/core/transferred", self.baseurl,);
9332        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9333        header_map.append(
9334            ::reqwest::header::HeaderName::from_static("api-version"),
9335            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9336        );
9337        #[allow(unused_mut)]
9338        let mut request = self
9339            .client
9340            .post(url)
9341            .header(
9342                ::reqwest::header::ACCEPT,
9343                ::reqwest::header::HeaderValue::from_static("application/json"),
9344            )
9345            .query(&progenitor_client::QueryParam::new("_async", &async_))
9346            .query(&progenitor_client::QueryParam::new("_group", &group))
9347            .query(&progenitor_client::QueryParam::new("group", &group))
9348            .headers(header_map)
9349            .build()?;
9350        let info = OperationInfo {
9351            operation_id: "core_transferred",
9352        };
9353        self.pre(&mut request, &info).await?;
9354        let result = self.exec(request, &info).await;
9355        self.post(&result, &info).await?;
9356        let response = result?;
9357        match response.status().as_u16() {
9358            200u16 => ResponseValue::from_response(response).await,
9359            400u16..=499u16 => Err(Error::ErrorResponse(
9360                ResponseValue::from_response(response).await?,
9361            )),
9362            500u16..=599u16 => Err(Error::ErrorResponse(
9363                ResponseValue::from_response(response).await?,
9364            )),
9365            _ => Err(Error::UnexpectedResponse(response)),
9366        }
9367    }
9368
9369    ///Sends a `POST` request to `/debug/set-block-profile-rate`
9370    ///
9371    ///Arguments:
9372    /// - `async_`: Run the command asynchronously. Returns a job id
9373    ///   immediately.
9374    /// - `group`: Assign the request to a custom stats group.
9375    /// - `rate`: Sampling interval in nanoseconds for blocking profile
9376    ///   collection; use 1 to capture all events.
9377    pub async fn debug_set_block_profile_rate<'a>(
9378        &'a self,
9379        async_: Option<bool>,
9380        group: Option<&'a str>,
9381        rate: i64,
9382    ) -> Result<
9383        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9384        Error<types::RcError>,
9385    > {
9386        let url = format!("{}/debug/set-block-profile-rate", self.baseurl,);
9387        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9388        header_map.append(
9389            ::reqwest::header::HeaderName::from_static("api-version"),
9390            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9391        );
9392        #[allow(unused_mut)]
9393        let mut request = self
9394            .client
9395            .post(url)
9396            .header(
9397                ::reqwest::header::ACCEPT,
9398                ::reqwest::header::HeaderValue::from_static("application/json"),
9399            )
9400            .query(&progenitor_client::QueryParam::new("_async", &async_))
9401            .query(&progenitor_client::QueryParam::new("_group", &group))
9402            .query(&progenitor_client::QueryParam::new("rate", &rate))
9403            .headers(header_map)
9404            .build()?;
9405        let info = OperationInfo {
9406            operation_id: "debug_set_block_profile_rate",
9407        };
9408        self.pre(&mut request, &info).await?;
9409        let result = self.exec(request, &info).await;
9410        self.post(&result, &info).await?;
9411        let response = result?;
9412        match response.status().as_u16() {
9413            200u16 => ResponseValue::from_response(response).await,
9414            400u16..=499u16 => Err(Error::ErrorResponse(
9415                ResponseValue::from_response(response).await?,
9416            )),
9417            500u16..=599u16 => Err(Error::ErrorResponse(
9418                ResponseValue::from_response(response).await?,
9419            )),
9420            _ => Err(Error::UnexpectedResponse(response)),
9421        }
9422    }
9423
9424    ///Sends a `POST` request to `/debug/set-gc-percent`
9425    ///
9426    ///Arguments:
9427    /// - `async_`: Run the command asynchronously. Returns a job id
9428    ///   immediately.
9429    /// - `group`: Assign the request to a custom stats group.
9430    /// - `gc_percent`: Target percentage of newly allocated data to trigger
9431    ///   garbage collection.
9432    pub async fn debug_set_gc_percent<'a>(
9433        &'a self,
9434        async_: Option<bool>,
9435        group: Option<&'a str>,
9436        gc_percent: i64,
9437    ) -> Result<ResponseValue<types::DebugSetGcPercentResponse>, Error<types::RcError>> {
9438        let url = format!("{}/debug/set-gc-percent", self.baseurl,);
9439        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9440        header_map.append(
9441            ::reqwest::header::HeaderName::from_static("api-version"),
9442            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9443        );
9444        #[allow(unused_mut)]
9445        let mut request = self
9446            .client
9447            .post(url)
9448            .header(
9449                ::reqwest::header::ACCEPT,
9450                ::reqwest::header::HeaderValue::from_static("application/json"),
9451            )
9452            .query(&progenitor_client::QueryParam::new("_async", &async_))
9453            .query(&progenitor_client::QueryParam::new("_group", &group))
9454            .query(&progenitor_client::QueryParam::new(
9455                "gc-percent",
9456                &gc_percent,
9457            ))
9458            .headers(header_map)
9459            .build()?;
9460        let info = OperationInfo {
9461            operation_id: "debug_set_gc_percent",
9462        };
9463        self.pre(&mut request, &info).await?;
9464        let result = self.exec(request, &info).await;
9465        self.post(&result, &info).await?;
9466        let response = result?;
9467        match response.status().as_u16() {
9468            200u16 => ResponseValue::from_response(response).await,
9469            400u16..=499u16 => Err(Error::ErrorResponse(
9470                ResponseValue::from_response(response).await?,
9471            )),
9472            500u16..=599u16 => Err(Error::ErrorResponse(
9473                ResponseValue::from_response(response).await?,
9474            )),
9475            _ => Err(Error::UnexpectedResponse(response)),
9476        }
9477    }
9478
9479    ///Sends a `POST` request to `/debug/set-mutex-profile-fraction`
9480    ///
9481    ///Arguments:
9482    /// - `async_`: Run the command asynchronously. Returns a job id
9483    ///   immediately.
9484    /// - `group`: Assign the request to a custom stats group.
9485    /// - `rate`: Sampling fraction for mutex contention profiling; set to 0 to
9486    ///   disable.
9487    pub async fn debug_set_mutex_profile_fraction<'a>(
9488        &'a self,
9489        async_: Option<bool>,
9490        group: Option<&'a str>,
9491        rate: i64,
9492    ) -> Result<ResponseValue<types::DebugSetMutexProfileFractionResponse>, Error<types::RcError>>
9493    {
9494        let url = format!("{}/debug/set-mutex-profile-fraction", self.baseurl,);
9495        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9496        header_map.append(
9497            ::reqwest::header::HeaderName::from_static("api-version"),
9498            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9499        );
9500        #[allow(unused_mut)]
9501        let mut request = self
9502            .client
9503            .post(url)
9504            .header(
9505                ::reqwest::header::ACCEPT,
9506                ::reqwest::header::HeaderValue::from_static("application/json"),
9507            )
9508            .query(&progenitor_client::QueryParam::new("_async", &async_))
9509            .query(&progenitor_client::QueryParam::new("_group", &group))
9510            .query(&progenitor_client::QueryParam::new("rate", &rate))
9511            .headers(header_map)
9512            .build()?;
9513        let info = OperationInfo {
9514            operation_id: "debug_set_mutex_profile_fraction",
9515        };
9516        self.pre(&mut request, &info).await?;
9517        let result = self.exec(request, &info).await;
9518        self.post(&result, &info).await?;
9519        let response = result?;
9520        match response.status().as_u16() {
9521            200u16 => ResponseValue::from_response(response).await,
9522            400u16..=499u16 => Err(Error::ErrorResponse(
9523                ResponseValue::from_response(response).await?,
9524            )),
9525            500u16..=599u16 => Err(Error::ErrorResponse(
9526                ResponseValue::from_response(response).await?,
9527            )),
9528            _ => Err(Error::UnexpectedResponse(response)),
9529        }
9530    }
9531
9532    ///Sends a `POST` request to `/debug/set-soft-memory-limit`
9533    ///
9534    ///Arguments:
9535    /// - `async_`: Run the command asynchronously. Returns a job id
9536    ///   immediately.
9537    /// - `group`: Assign the request to a custom stats group.
9538    /// - `mem_limit`: Soft memory limit for the Go runtime in bytes.
9539    pub async fn debug_set_soft_memory_limit<'a>(
9540        &'a self,
9541        async_: Option<bool>,
9542        group: Option<&'a str>,
9543        mem_limit: i64,
9544    ) -> Result<ResponseValue<types::DebugSetSoftMemoryLimitResponse>, Error<types::RcError>> {
9545        let url = format!("{}/debug/set-soft-memory-limit", self.baseurl,);
9546        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9547        header_map.append(
9548            ::reqwest::header::HeaderName::from_static("api-version"),
9549            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9550        );
9551        #[allow(unused_mut)]
9552        let mut request = self
9553            .client
9554            .post(url)
9555            .header(
9556                ::reqwest::header::ACCEPT,
9557                ::reqwest::header::HeaderValue::from_static("application/json"),
9558            )
9559            .query(&progenitor_client::QueryParam::new("_async", &async_))
9560            .query(&progenitor_client::QueryParam::new("_group", &group))
9561            .query(&progenitor_client::QueryParam::new("mem-limit", &mem_limit))
9562            .headers(header_map)
9563            .build()?;
9564        let info = OperationInfo {
9565            operation_id: "debug_set_soft_memory_limit",
9566        };
9567        self.pre(&mut request, &info).await?;
9568        let result = self.exec(request, &info).await;
9569        self.post(&result, &info).await?;
9570        let response = result?;
9571        match response.status().as_u16() {
9572            200u16 => ResponseValue::from_response(response).await,
9573            400u16..=499u16 => Err(Error::ErrorResponse(
9574                ResponseValue::from_response(response).await?,
9575            )),
9576            500u16..=599u16 => Err(Error::ErrorResponse(
9577                ResponseValue::from_response(response).await?,
9578            )),
9579            _ => Err(Error::UnexpectedResponse(response)),
9580        }
9581    }
9582
9583    ///Sends a `POST` request to `/fscache/clear`
9584    ///
9585    ///Arguments:
9586    /// - `async_`: Run the command asynchronously. Returns a job id
9587    ///   immediately.
9588    /// - `group`: Assign the request to a custom stats group.
9589    pub async fn fscache_clear<'a>(
9590        &'a self,
9591        async_: Option<bool>,
9592        group: Option<&'a str>,
9593    ) -> Result<
9594        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9595        Error<types::RcError>,
9596    > {
9597        let url = format!("{}/fscache/clear", self.baseurl,);
9598        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9599        header_map.append(
9600            ::reqwest::header::HeaderName::from_static("api-version"),
9601            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9602        );
9603        #[allow(unused_mut)]
9604        let mut request = self
9605            .client
9606            .post(url)
9607            .header(
9608                ::reqwest::header::ACCEPT,
9609                ::reqwest::header::HeaderValue::from_static("application/json"),
9610            )
9611            .query(&progenitor_client::QueryParam::new("_async", &async_))
9612            .query(&progenitor_client::QueryParam::new("_group", &group))
9613            .headers(header_map)
9614            .build()?;
9615        let info = OperationInfo {
9616            operation_id: "fscache_clear",
9617        };
9618        self.pre(&mut request, &info).await?;
9619        let result = self.exec(request, &info).await;
9620        self.post(&result, &info).await?;
9621        let response = result?;
9622        match response.status().as_u16() {
9623            200u16 => ResponseValue::from_response(response).await,
9624            400u16..=499u16 => Err(Error::ErrorResponse(
9625                ResponseValue::from_response(response).await?,
9626            )),
9627            500u16..=599u16 => Err(Error::ErrorResponse(
9628                ResponseValue::from_response(response).await?,
9629            )),
9630            _ => Err(Error::UnexpectedResponse(response)),
9631        }
9632    }
9633
9634    ///Sends a `POST` request to `/fscache/entries`
9635    ///
9636    ///Arguments:
9637    /// - `async_`: Run the command asynchronously. Returns a job id
9638    ///   immediately.
9639    /// - `group`: Assign the request to a custom stats group.
9640    pub async fn fscache_entries<'a>(
9641        &'a self,
9642        async_: Option<bool>,
9643        group: Option<&'a str>,
9644    ) -> Result<ResponseValue<types::FscacheEntriesResponse>, Error<types::RcError>> {
9645        let url = format!("{}/fscache/entries", self.baseurl,);
9646        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9647        header_map.append(
9648            ::reqwest::header::HeaderName::from_static("api-version"),
9649            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9650        );
9651        #[allow(unused_mut)]
9652        let mut request = self
9653            .client
9654            .post(url)
9655            .header(
9656                ::reqwest::header::ACCEPT,
9657                ::reqwest::header::HeaderValue::from_static("application/json"),
9658            )
9659            .query(&progenitor_client::QueryParam::new("_async", &async_))
9660            .query(&progenitor_client::QueryParam::new("_group", &group))
9661            .headers(header_map)
9662            .build()?;
9663        let info = OperationInfo {
9664            operation_id: "fscache_entries",
9665        };
9666        self.pre(&mut request, &info).await?;
9667        let result = self.exec(request, &info).await;
9668        self.post(&result, &info).await?;
9669        let response = result?;
9670        match response.status().as_u16() {
9671            200u16 => ResponseValue::from_response(response).await,
9672            400u16..=499u16 => Err(Error::ErrorResponse(
9673                ResponseValue::from_response(response).await?,
9674            )),
9675            500u16..=599u16 => Err(Error::ErrorResponse(
9676                ResponseValue::from_response(response).await?,
9677            )),
9678            _ => Err(Error::UnexpectedResponse(response)),
9679        }
9680    }
9681
9682    ///Sends a `POST` request to `/mount/listmounts`
9683    ///
9684    ///Arguments:
9685    /// - `async_`: Run the command asynchronously. Returns a job id
9686    ///   immediately.
9687    /// - `group`: Assign the request to a custom stats group.
9688    pub async fn mount_listmounts<'a>(
9689        &'a self,
9690        async_: Option<bool>,
9691        group: Option<&'a str>,
9692    ) -> Result<ResponseValue<types::MountListmountsResponse>, Error<types::RcError>> {
9693        let url = format!("{}/mount/listmounts", self.baseurl,);
9694        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9695        header_map.append(
9696            ::reqwest::header::HeaderName::from_static("api-version"),
9697            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9698        );
9699        #[allow(unused_mut)]
9700        let mut request = self
9701            .client
9702            .post(url)
9703            .header(
9704                ::reqwest::header::ACCEPT,
9705                ::reqwest::header::HeaderValue::from_static("application/json"),
9706            )
9707            .query(&progenitor_client::QueryParam::new("_async", &async_))
9708            .query(&progenitor_client::QueryParam::new("_group", &group))
9709            .headers(header_map)
9710            .build()?;
9711        let info = OperationInfo {
9712            operation_id: "mount_listmounts",
9713        };
9714        self.pre(&mut request, &info).await?;
9715        let result = self.exec(request, &info).await;
9716        self.post(&result, &info).await?;
9717        let response = result?;
9718        match response.status().as_u16() {
9719            200u16 => ResponseValue::from_response(response).await,
9720            400u16..=499u16 => Err(Error::ErrorResponse(
9721                ResponseValue::from_response(response).await?,
9722            )),
9723            500u16..=599u16 => Err(Error::ErrorResponse(
9724                ResponseValue::from_response(response).await?,
9725            )),
9726            _ => Err(Error::UnexpectedResponse(response)),
9727        }
9728    }
9729
9730    ///Sends a `POST` request to `/mount/mount`
9731    ///
9732    ///Arguments:
9733    /// - `async_`: Run the command asynchronously. Returns a job id
9734    ///   immediately.
9735    /// - `config`: JSON encoded config overrides applied for this call only.
9736    /// - `filter`: JSON encoded filter overrides applied for this call only.
9737    /// - `group`: Assign the request to a custom stats group.
9738    /// - `fs`: Remote path to mount, such as `drive:` or `remote:subdir`.
9739    /// - `mount_opt`: Mount options encoded as JSON, matching flags accepted by
9740    ///   `rclone mount`.
9741    /// - `mount_point`: Absolute local path where the remote should be mounted.
9742    /// - `mount_type`: Optional mount implementation to use (`mount`, `cmount`,
9743    ///   or `mount2`).
9744    /// - `vfs_opt`: VFS options encoded as JSON, matching flags accepted by
9745    ///   `rclone mount`.
9746    pub async fn mount_mount<'a>(
9747        &'a self,
9748        async_: Option<bool>,
9749        config: Option<&'a str>,
9750        filter: Option<&'a str>,
9751        group: Option<&'a str>,
9752        fs: &'a str,
9753        mount_opt: Option<&'a str>,
9754        mount_point: &'a str,
9755        mount_type: Option<&'a str>,
9756        vfs_opt: Option<&'a str>,
9757    ) -> Result<
9758        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9759        Error<types::RcError>,
9760    > {
9761        let url = format!("{}/mount/mount", self.baseurl,);
9762        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9763        header_map.append(
9764            ::reqwest::header::HeaderName::from_static("api-version"),
9765            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9766        );
9767        #[allow(unused_mut)]
9768        let mut request = self
9769            .client
9770            .post(url)
9771            .header(
9772                ::reqwest::header::ACCEPT,
9773                ::reqwest::header::HeaderValue::from_static("application/json"),
9774            )
9775            .query(&progenitor_client::QueryParam::new("_async", &async_))
9776            .query(&progenitor_client::QueryParam::new("_config", &config))
9777            .query(&progenitor_client::QueryParam::new("_filter", &filter))
9778            .query(&progenitor_client::QueryParam::new("_group", &group))
9779            .query(&progenitor_client::QueryParam::new("fs", &fs))
9780            .query(&progenitor_client::QueryParam::new("mountOpt", &mount_opt))
9781            .query(&progenitor_client::QueryParam::new(
9782                "mountPoint",
9783                &mount_point,
9784            ))
9785            .query(&progenitor_client::QueryParam::new(
9786                "mountType",
9787                &mount_type,
9788            ))
9789            .query(&progenitor_client::QueryParam::new("vfsOpt", &vfs_opt))
9790            .headers(header_map)
9791            .build()?;
9792        let info = OperationInfo {
9793            operation_id: "mount_mount",
9794        };
9795        self.pre(&mut request, &info).await?;
9796        let result = self.exec(request, &info).await;
9797        self.post(&result, &info).await?;
9798        let response = result?;
9799        match response.status().as_u16() {
9800            200u16 => ResponseValue::from_response(response).await,
9801            400u16..=499u16 => Err(Error::ErrorResponse(
9802                ResponseValue::from_response(response).await?,
9803            )),
9804            500u16..=599u16 => Err(Error::ErrorResponse(
9805                ResponseValue::from_response(response).await?,
9806            )),
9807            _ => Err(Error::UnexpectedResponse(response)),
9808        }
9809    }
9810
9811    ///Sends a `POST` request to `/mount/types`
9812    ///
9813    ///Arguments:
9814    /// - `async_`: Run the command asynchronously. Returns a job id
9815    ///   immediately.
9816    /// - `group`: Assign the request to a custom stats group.
9817    pub async fn mount_types<'a>(
9818        &'a self,
9819        async_: Option<bool>,
9820        group: Option<&'a str>,
9821    ) -> Result<ResponseValue<types::MountTypesResponse>, Error<types::RcError>> {
9822        let url = format!("{}/mount/types", self.baseurl,);
9823        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9824        header_map.append(
9825            ::reqwest::header::HeaderName::from_static("api-version"),
9826            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9827        );
9828        #[allow(unused_mut)]
9829        let mut request = self
9830            .client
9831            .post(url)
9832            .header(
9833                ::reqwest::header::ACCEPT,
9834                ::reqwest::header::HeaderValue::from_static("application/json"),
9835            )
9836            .query(&progenitor_client::QueryParam::new("_async", &async_))
9837            .query(&progenitor_client::QueryParam::new("_group", &group))
9838            .headers(header_map)
9839            .build()?;
9840        let info = OperationInfo {
9841            operation_id: "mount_types",
9842        };
9843        self.pre(&mut request, &info).await?;
9844        let result = self.exec(request, &info).await;
9845        self.post(&result, &info).await?;
9846        let response = result?;
9847        match response.status().as_u16() {
9848            200u16 => ResponseValue::from_response(response).await,
9849            400u16..=499u16 => Err(Error::ErrorResponse(
9850                ResponseValue::from_response(response).await?,
9851            )),
9852            500u16..=599u16 => Err(Error::ErrorResponse(
9853                ResponseValue::from_response(response).await?,
9854            )),
9855            _ => Err(Error::UnexpectedResponse(response)),
9856        }
9857    }
9858
9859    ///Sends a `POST` request to `/mount/unmount`
9860    ///
9861    ///Arguments:
9862    /// - `async_`: Run the command asynchronously. Returns a job id
9863    ///   immediately.
9864    /// - `group`: Assign the request to a custom stats group.
9865    /// - `mount_point`: Local mount point path to unmount.
9866    pub async fn mount_unmount<'a>(
9867        &'a self,
9868        async_: Option<bool>,
9869        group: Option<&'a str>,
9870        mount_point: &'a str,
9871    ) -> Result<
9872        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9873        Error<types::RcError>,
9874    > {
9875        let url = format!("{}/mount/unmount", self.baseurl,);
9876        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9877        header_map.append(
9878            ::reqwest::header::HeaderName::from_static("api-version"),
9879            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9880        );
9881        #[allow(unused_mut)]
9882        let mut request = self
9883            .client
9884            .post(url)
9885            .header(
9886                ::reqwest::header::ACCEPT,
9887                ::reqwest::header::HeaderValue::from_static("application/json"),
9888            )
9889            .query(&progenitor_client::QueryParam::new("_async", &async_))
9890            .query(&progenitor_client::QueryParam::new("_group", &group))
9891            .query(&progenitor_client::QueryParam::new(
9892                "mountPoint",
9893                &mount_point,
9894            ))
9895            .headers(header_map)
9896            .build()?;
9897        let info = OperationInfo {
9898            operation_id: "mount_unmount",
9899        };
9900        self.pre(&mut request, &info).await?;
9901        let result = self.exec(request, &info).await;
9902        self.post(&result, &info).await?;
9903        let response = result?;
9904        match response.status().as_u16() {
9905            200u16 => ResponseValue::from_response(response).await,
9906            400u16..=499u16 => Err(Error::ErrorResponse(
9907                ResponseValue::from_response(response).await?,
9908            )),
9909            500u16..=599u16 => Err(Error::ErrorResponse(
9910                ResponseValue::from_response(response).await?,
9911            )),
9912            _ => Err(Error::UnexpectedResponse(response)),
9913        }
9914    }
9915
9916    ///Sends a `POST` request to `/mount/unmountall`
9917    ///
9918    ///Arguments:
9919    /// - `async_`: Run the command asynchronously. Returns a job id
9920    ///   immediately.
9921    /// - `group`: Assign the request to a custom stats group.
9922    pub async fn mount_unmountall<'a>(
9923        &'a self,
9924        async_: Option<bool>,
9925        group: Option<&'a str>,
9926    ) -> Result<
9927        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9928        Error<types::RcError>,
9929    > {
9930        let url = format!("{}/mount/unmountall", self.baseurl,);
9931        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9932        header_map.append(
9933            ::reqwest::header::HeaderName::from_static("api-version"),
9934            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9935        );
9936        #[allow(unused_mut)]
9937        let mut request = self
9938            .client
9939            .post(url)
9940            .header(
9941                ::reqwest::header::ACCEPT,
9942                ::reqwest::header::HeaderValue::from_static("application/json"),
9943            )
9944            .query(&progenitor_client::QueryParam::new("_async", &async_))
9945            .query(&progenitor_client::QueryParam::new("_group", &group))
9946            .headers(header_map)
9947            .build()?;
9948        let info = OperationInfo {
9949            operation_id: "mount_unmountall",
9950        };
9951        self.pre(&mut request, &info).await?;
9952        let result = self.exec(request, &info).await;
9953        self.post(&result, &info).await?;
9954        let response = result?;
9955        match response.status().as_u16() {
9956            200u16 => ResponseValue::from_response(response).await,
9957            400u16..=499u16 => Err(Error::ErrorResponse(
9958                ResponseValue::from_response(response).await?,
9959            )),
9960            500u16..=599u16 => Err(Error::ErrorResponse(
9961                ResponseValue::from_response(response).await?,
9962            )),
9963            _ => Err(Error::UnexpectedResponse(response)),
9964        }
9965    }
9966
9967    ///Echo parameters (auth required)
9968    ///
9969    ///Same as `rc/noop`, but requires authentication to validate access
9970    /// control.
9971    ///
9972    ///Sends a `POST` request to `/rc/noopauth`
9973    ///
9974    ///Arguments:
9975    /// - `async_`: Run the command asynchronously. Returns a job id
9976    ///   immediately.
9977    /// - `params`: Additional arbitrary parameters allowed.
9978    pub async fn rc_noop_auth<'a>(
9979        &'a self,
9980        async_: Option<bool>,
9981        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9982    ) -> Result<
9983        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9984        Error<types::RcError>,
9985    > {
9986        let url = format!("{}/rc/noopauth", self.baseurl,);
9987        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9988        header_map.append(
9989            ::reqwest::header::HeaderName::from_static("api-version"),
9990            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9991        );
9992        #[allow(unused_mut)]
9993        let mut request = self
9994            .client
9995            .post(url)
9996            .header(
9997                ::reqwest::header::ACCEPT,
9998                ::reqwest::header::HeaderValue::from_static("application/json"),
9999            )
10000            .query(&progenitor_client::QueryParam::new("_async", &async_))
10001            .query(&progenitor_client::QueryParam::new("params", &params))
10002            .headers(header_map)
10003            .build()?;
10004        let info = OperationInfo {
10005            operation_id: "rc_noop_auth",
10006        };
10007        self.pre(&mut request, &info).await?;
10008        let result = self.exec(request, &info).await;
10009        self.post(&result, &info).await?;
10010        let response = result?;
10011        match response.status().as_u16() {
10012            200u16 => ResponseValue::from_response(response).await,
10013            400u16..=499u16 => Err(Error::ErrorResponse(
10014                ResponseValue::from_response(response).await?,
10015            )),
10016            500u16..=599u16 => Err(Error::ErrorResponse(
10017                ResponseValue::from_response(response).await?,
10018            )),
10019            _ => Err(Error::UnexpectedResponse(response)),
10020        }
10021    }
10022
10023    ///Return a test error
10024    ///
10025    ///Always returns an error response incorporating the supplied parameters,
10026    /// useful for testing error handling.
10027    ///
10028    ///Sends a `POST` request to `/rc/error`
10029    ///
10030    ///Arguments:
10031    /// - `async_`: Run the command asynchronously. Returns a job id
10032    ///   immediately.
10033    /// - `params`: Additional arbitrary parameters allowed.
10034    pub async fn rc_error<'a>(
10035        &'a self,
10036        async_: Option<bool>,
10037        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10038    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10039        let url = format!("{}/rc/error", self.baseurl,);
10040        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10041        header_map.append(
10042            ::reqwest::header::HeaderName::from_static("api-version"),
10043            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10044        );
10045        #[allow(unused_mut)]
10046        let mut request = self
10047            .client
10048            .post(url)
10049            .header(
10050                ::reqwest::header::ACCEPT,
10051                ::reqwest::header::HeaderValue::from_static("application/json"),
10052            )
10053            .query(&progenitor_client::QueryParam::new("_async", &async_))
10054            .query(&progenitor_client::QueryParam::new("params", &params))
10055            .headers(header_map)
10056            .build()?;
10057        let info = OperationInfo {
10058            operation_id: "rc_error",
10059        };
10060        self.pre(&mut request, &info).await?;
10061        let result = self.exec(request, &info).await;
10062        self.post(&result, &info).await?;
10063        let response = result?;
10064        match response.status().as_u16() {
10065            200u16 => Ok(ResponseValue::empty(response)),
10066            400u16..=499u16 => Err(Error::ErrorResponse(
10067                ResponseValue::from_response(response).await?,
10068            )),
10069            500u16..=599u16 => Err(Error::ErrorResponse(
10070                ResponseValue::from_response(response).await?,
10071            )),
10072            _ => Err(Error::UnexpectedResponse(response)),
10073        }
10074    }
10075
10076    ///List RC commands
10077    ///
10078    ///Returns metadata about every available RC command, including whether
10079    /// authentication is required.
10080    ///
10081    ///Sends a `POST` request to `/rc/list`
10082    ///
10083    ///Arguments:
10084    /// - `async_`: Run the command asynchronously. Returns a job id
10085    ///   immediately.
10086    /// - `group`: Assign the request to a custom stats group.
10087    pub async fn rc_list<'a>(
10088        &'a self,
10089        async_: Option<bool>,
10090        group: Option<&'a str>,
10091    ) -> Result<ResponseValue<types::RcListResponse>, Error<types::RcError>> {
10092        let url = format!("{}/rc/list", self.baseurl,);
10093        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10094        header_map.append(
10095            ::reqwest::header::HeaderName::from_static("api-version"),
10096            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10097        );
10098        #[allow(unused_mut)]
10099        let mut request = self
10100            .client
10101            .post(url)
10102            .header(
10103                ::reqwest::header::ACCEPT,
10104                ::reqwest::header::HeaderValue::from_static("application/json"),
10105            )
10106            .query(&progenitor_client::QueryParam::new("_async", &async_))
10107            .query(&progenitor_client::QueryParam::new("_group", &group))
10108            .headers(header_map)
10109            .build()?;
10110        let info = OperationInfo {
10111            operation_id: "rc_list",
10112        };
10113        self.pre(&mut request, &info).await?;
10114        let result = self.exec(request, &info).await;
10115        self.post(&result, &info).await?;
10116        let response = result?;
10117        match response.status().as_u16() {
10118            200u16 => ResponseValue::from_response(response).await,
10119            400u16..=499u16 => Err(Error::ErrorResponse(
10120                ResponseValue::from_response(response).await?,
10121            )),
10122            500u16..=599u16 => Err(Error::ErrorResponse(
10123                ResponseValue::from_response(response).await?,
10124            )),
10125            _ => Err(Error::UnexpectedResponse(response)),
10126        }
10127    }
10128
10129    ///Run backend command
10130    ///
10131    ///Invokes a backend-specific management command against an optional
10132    /// remote.
10133    ///
10134    ///Sends a `POST` request to `/backend/command`
10135    ///
10136    ///Arguments:
10137    /// - `async_`: Run the command asynchronously. Returns a job id
10138    ///   immediately.
10139    /// - `group`: Assign the request to a custom stats group.
10140    /// - `arg`: Optional positional arguments for the backend command.
10141    /// - `command`: Backend-specific command to invoke.
10142    /// - `fs`: Remote name or path the backend command should target.
10143    /// - `opt`: Backend command options encoded as a JSON string.
10144    pub async fn backend_command<'a>(
10145        &'a self,
10146        async_: Option<bool>,
10147        group: Option<&'a str>,
10148        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
10149        command: &'a str,
10150        fs: Option<&'a str>,
10151        opt: Option<&'a str>,
10152    ) -> Result<ResponseValue<types::BackendCommandResponse>, Error<types::RcError>> {
10153        let url = format!("{}/backend/command", self.baseurl,);
10154        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10155        header_map.append(
10156            ::reqwest::header::HeaderName::from_static("api-version"),
10157            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10158        );
10159        #[allow(unused_mut)]
10160        let mut request = self
10161            .client
10162            .post(url)
10163            .header(
10164                ::reqwest::header::ACCEPT,
10165                ::reqwest::header::HeaderValue::from_static("application/json"),
10166            )
10167            .query(&progenitor_client::QueryParam::new("_async", &async_))
10168            .query(&progenitor_client::QueryParam::new("_group", &group))
10169            .query(&progenitor_client::QueryParam::new("arg", &arg))
10170            .query(&progenitor_client::QueryParam::new("command", &command))
10171            .query(&progenitor_client::QueryParam::new("fs", &fs))
10172            .query(&progenitor_client::QueryParam::new("opt", &opt))
10173            .headers(header_map)
10174            .build()?;
10175        let info = OperationInfo {
10176            operation_id: "backend_command",
10177        };
10178        self.pre(&mut request, &info).await?;
10179        let result = self.exec(request, &info).await;
10180        self.post(&result, &info).await?;
10181        let response = result?;
10182        match response.status().as_u16() {
10183            200u16 => ResponseValue::from_response(response).await,
10184            400u16..=499u16 => Err(Error::ErrorResponse(
10185                ResponseValue::from_response(response).await?,
10186            )),
10187            500u16..=599u16 => Err(Error::ErrorResponse(
10188                ResponseValue::from_response(response).await?,
10189            )),
10190            _ => Err(Error::UnexpectedResponse(response)),
10191        }
10192    }
10193
10194    ///Expire cache entries
10195    ///
10196    ///Drops cached directory entries, and optionally cached file data, for the
10197    /// cache backend.
10198    ///
10199    ///Sends a `POST` request to `/cache/expire`
10200    ///
10201    ///Arguments:
10202    /// - `async_`: Run the command asynchronously. Returns a job id
10203    ///   immediately.
10204    /// - `group`: Assign the request to a custom stats group.
10205    /// - `remote`: Remote path to expire from the cache, e.g.
10206    ///   `remote:path/to/dir`.
10207    /// - `with_data`: Set to true to drop cached chunk data along with
10208    ///   directory entries.
10209    pub async fn cache_expire<'a>(
10210        &'a self,
10211        async_: Option<bool>,
10212        group: Option<&'a str>,
10213        remote: &'a str,
10214        with_data: Option<bool>,
10215    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10216        let url = format!("{}/cache/expire", self.baseurl,);
10217        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10218        header_map.append(
10219            ::reqwest::header::HeaderName::from_static("api-version"),
10220            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10221        );
10222        #[allow(unused_mut)]
10223        let mut request = self
10224            .client
10225            .post(url)
10226            .header(
10227                ::reqwest::header::ACCEPT,
10228                ::reqwest::header::HeaderValue::from_static("application/json"),
10229            )
10230            .query(&progenitor_client::QueryParam::new("_async", &async_))
10231            .query(&progenitor_client::QueryParam::new("_group", &group))
10232            .query(&progenitor_client::QueryParam::new("remote", &remote))
10233            .query(&progenitor_client::QueryParam::new("withData", &with_data))
10234            .headers(header_map)
10235            .build()?;
10236        let info = OperationInfo {
10237            operation_id: "cache_expire",
10238        };
10239        self.pre(&mut request, &info).await?;
10240        let result = self.exec(request, &info).await;
10241        self.post(&result, &info).await?;
10242        let response = result?;
10243        match response.status().as_u16() {
10244            200u16 => Ok(ResponseValue::empty(response)),
10245            400u16..=499u16 => Err(Error::ErrorResponse(
10246                ResponseValue::from_response(response).await?,
10247            )),
10248            500u16..=599u16 => Err(Error::ErrorResponse(
10249                ResponseValue::from_response(response).await?,
10250            )),
10251            _ => Err(Error::UnexpectedResponse(response)),
10252        }
10253    }
10254
10255    ///Prefetch cache chunks
10256    ///
10257    ///Ensures specified file chunks are cached locally for a cache remote.
10258    ///
10259    ///Sends a `POST` request to `/cache/fetch`
10260    ///
10261    ///Arguments:
10262    /// - `async_`: Run the command asynchronously. Returns a job id
10263    ///   immediately.
10264    /// - `group`: Assign the request to a custom stats group.
10265    /// - `chunks`: Comma-separated chunk specifier list (e.g. `0:10,25:30`)
10266    ///   describing file pieces to prefetch.
10267    /// - `params`: Additional arbitrary parameters allowed.
10268    pub async fn cache_fetch<'a>(
10269        &'a self,
10270        async_: Option<bool>,
10271        group: Option<&'a str>,
10272        chunks: Option<&'a str>,
10273        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10274    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10275        let url = format!("{}/cache/fetch", self.baseurl,);
10276        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10277        header_map.append(
10278            ::reqwest::header::HeaderName::from_static("api-version"),
10279            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10280        );
10281        #[allow(unused_mut)]
10282        let mut request = self
10283            .client
10284            .post(url)
10285            .header(
10286                ::reqwest::header::ACCEPT,
10287                ::reqwest::header::HeaderValue::from_static("application/json"),
10288            )
10289            .query(&progenitor_client::QueryParam::new("_async", &async_))
10290            .query(&progenitor_client::QueryParam::new("_group", &group))
10291            .query(&progenitor_client::QueryParam::new("chunks", &chunks))
10292            .query(&progenitor_client::QueryParam::new("params", &params))
10293            .headers(header_map)
10294            .build()?;
10295        let info = OperationInfo {
10296            operation_id: "cache_fetch",
10297        };
10298        self.pre(&mut request, &info).await?;
10299        let result = self.exec(request, &info).await;
10300        self.post(&result, &info).await?;
10301        let response = result?;
10302        match response.status().as_u16() {
10303            200u16 => Ok(ResponseValue::empty(response)),
10304            400u16..=499u16 => Err(Error::ErrorResponse(
10305                ResponseValue::from_response(response).await?,
10306            )),
10307            500u16..=599u16 => Err(Error::ErrorResponse(
10308                ResponseValue::from_response(response).await?,
10309            )),
10310            _ => Err(Error::UnexpectedResponse(response)),
10311        }
10312    }
10313
10314    ///Show cache stats
10315    ///
10316    ///Returns runtime statistics for the cache backend.
10317    ///
10318    ///Sends a `POST` request to `/cache/stats`
10319    ///
10320    ///Arguments:
10321    /// - `async_`: Run the command asynchronously. Returns a job id
10322    ///   immediately.
10323    /// - `group`: Assign the request to a custom stats group.
10324    pub async fn cache_stats<'a>(
10325        &'a self,
10326        async_: Option<bool>,
10327        group: Option<&'a str>,
10328    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10329        let url = format!("{}/cache/stats", self.baseurl,);
10330        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10331        header_map.append(
10332            ::reqwest::header::HeaderName::from_static("api-version"),
10333            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10334        );
10335        #[allow(unused_mut)]
10336        let mut request = self
10337            .client
10338            .post(url)
10339            .header(
10340                ::reqwest::header::ACCEPT,
10341                ::reqwest::header::HeaderValue::from_static("application/json"),
10342            )
10343            .query(&progenitor_client::QueryParam::new("_async", &async_))
10344            .query(&progenitor_client::QueryParam::new("_group", &group))
10345            .headers(header_map)
10346            .build()?;
10347        let info = OperationInfo {
10348            operation_id: "cache_stats",
10349        };
10350        self.pre(&mut request, &info).await?;
10351        let result = self.exec(request, &info).await;
10352        self.post(&result, &info).await?;
10353        let response = result?;
10354        match response.status().as_u16() {
10355            200u16 => Ok(ResponseValue::empty(response)),
10356            400u16..=499u16 => Err(Error::ErrorResponse(
10357                ResponseValue::from_response(response).await?,
10358            )),
10359            500u16..=599u16 => Err(Error::ErrorResponse(
10360                ResponseValue::from_response(response).await?,
10361            )),
10362            _ => Err(Error::UnexpectedResponse(response)),
10363        }
10364    }
10365
10366    ///Create remote configuration
10367    ///
10368    ///Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
10369    ///
10370    ///Sends a `POST` request to `/config/create`
10371    ///
10372    ///Arguments:
10373    /// - `async_`: Run the command asynchronously. Returns a job id
10374    ///   immediately.
10375    /// - `group`: Assign the request to a custom stats group.
10376    /// - `name`: Name of the new remote configuration.
10377    /// - `opt`: Optional JSON object controlling interactive behaviour (e.g.
10378    ///   `obscure`, `continue`).
10379    /// - `parameters`: JSON object of configuration key/value pairs required
10380    ///   for the remote.
10381    /// - `type_`: Backend type identifier, such as `drive`, `s3`, or `dropbox`.
10382    pub async fn config_create<'a>(
10383        &'a self,
10384        async_: Option<bool>,
10385        group: Option<&'a str>,
10386        name: &'a str,
10387        opt: Option<&'a str>,
10388        parameters: &'a str,
10389        type_: &'a str,
10390    ) -> Result<
10391        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10392        Error<types::RcError>,
10393    > {
10394        let url = format!("{}/config/create", self.baseurl,);
10395        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10396        header_map.append(
10397            ::reqwest::header::HeaderName::from_static("api-version"),
10398            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10399        );
10400        #[allow(unused_mut)]
10401        let mut request = self
10402            .client
10403            .post(url)
10404            .header(
10405                ::reqwest::header::ACCEPT,
10406                ::reqwest::header::HeaderValue::from_static("application/json"),
10407            )
10408            .query(&progenitor_client::QueryParam::new("_async", &async_))
10409            .query(&progenitor_client::QueryParam::new("_group", &group))
10410            .query(&progenitor_client::QueryParam::new("name", &name))
10411            .query(&progenitor_client::QueryParam::new("opt", &opt))
10412            .query(&progenitor_client::QueryParam::new(
10413                "parameters",
10414                &parameters,
10415            ))
10416            .query(&progenitor_client::QueryParam::new("type", &type_))
10417            .headers(header_map)
10418            .build()?;
10419        let info = OperationInfo {
10420            operation_id: "config_create",
10421        };
10422        self.pre(&mut request, &info).await?;
10423        let result = self.exec(request, &info).await;
10424        self.post(&result, &info).await?;
10425        let response = result?;
10426        match response.status().as_u16() {
10427            200u16 => ResponseValue::from_response(response).await,
10428            400u16..=499u16 => Err(Error::ErrorResponse(
10429                ResponseValue::from_response(response).await?,
10430            )),
10431            500u16..=599u16 => Err(Error::ErrorResponse(
10432                ResponseValue::from_response(response).await?,
10433            )),
10434            _ => Err(Error::UnexpectedResponse(response)),
10435        }
10436    }
10437
10438    ///Delete remote configuration
10439    ///
10440    ///Removes an existing remote from `rclone.conf`.
10441    ///
10442    ///Sends a `POST` request to `/config/delete`
10443    ///
10444    ///Arguments:
10445    /// - `async_`: Run the command asynchronously. Returns a job id
10446    ///   immediately.
10447    /// - `group`: Assign the request to a custom stats group.
10448    /// - `name`: Name of the remote configuration to delete.
10449    pub async fn config_delete<'a>(
10450        &'a self,
10451        async_: Option<bool>,
10452        group: Option<&'a str>,
10453        name: &'a str,
10454    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10455        let url = format!("{}/config/delete", self.baseurl,);
10456        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10457        header_map.append(
10458            ::reqwest::header::HeaderName::from_static("api-version"),
10459            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10460        );
10461        #[allow(unused_mut)]
10462        let mut request = self
10463            .client
10464            .post(url)
10465            .header(
10466                ::reqwest::header::ACCEPT,
10467                ::reqwest::header::HeaderValue::from_static("application/json"),
10468            )
10469            .query(&progenitor_client::QueryParam::new("_async", &async_))
10470            .query(&progenitor_client::QueryParam::new("_group", &group))
10471            .query(&progenitor_client::QueryParam::new("name", &name))
10472            .headers(header_map)
10473            .build()?;
10474        let info = OperationInfo {
10475            operation_id: "config_delete",
10476        };
10477        self.pre(&mut request, &info).await?;
10478        let result = self.exec(request, &info).await;
10479        self.post(&result, &info).await?;
10480        let response = result?;
10481        match response.status().as_u16() {
10482            200u16 => Ok(ResponseValue::empty(response)),
10483            400u16..=499u16 => Err(Error::ErrorResponse(
10484                ResponseValue::from_response(response).await?,
10485            )),
10486            500u16..=599u16 => Err(Error::ErrorResponse(
10487                ResponseValue::from_response(response).await?,
10488            )),
10489            _ => Err(Error::UnexpectedResponse(response)),
10490        }
10491    }
10492
10493    ///Dump configuration
10494    ///
10495    ///Returns the contents of the config file as a JSON object keyed by remote
10496    /// name.
10497    ///
10498    ///Sends a `POST` request to `/config/dump`
10499    ///
10500    ///Arguments:
10501    /// - `async_`: Run the command asynchronously. Returns a job id
10502    ///   immediately.
10503    /// - `group`: Assign the request to a custom stats group.
10504    pub async fn config_dump<'a>(
10505        &'a self,
10506        async_: Option<bool>,
10507        group: Option<&'a str>,
10508    ) -> Result<
10509        ResponseValue<
10510            ::std::collections::HashMap<
10511                ::std::string::String,
10512                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
10513            >,
10514        >,
10515        Error<types::RcError>,
10516    > {
10517        let url = format!("{}/config/dump", self.baseurl,);
10518        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10519        header_map.append(
10520            ::reqwest::header::HeaderName::from_static("api-version"),
10521            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10522        );
10523        #[allow(unused_mut)]
10524        let mut request = self
10525            .client
10526            .post(url)
10527            .header(
10528                ::reqwest::header::ACCEPT,
10529                ::reqwest::header::HeaderValue::from_static("application/json"),
10530            )
10531            .query(&progenitor_client::QueryParam::new("_async", &async_))
10532            .query(&progenitor_client::QueryParam::new("_group", &group))
10533            .headers(header_map)
10534            .build()?;
10535        let info = OperationInfo {
10536            operation_id: "config_dump",
10537        };
10538        self.pre(&mut request, &info).await?;
10539        let result = self.exec(request, &info).await;
10540        self.post(&result, &info).await?;
10541        let response = result?;
10542        match response.status().as_u16() {
10543            200u16 => ResponseValue::from_response(response).await,
10544            400u16..=499u16 => Err(Error::ErrorResponse(
10545                ResponseValue::from_response(response).await?,
10546            )),
10547            500u16..=599u16 => Err(Error::ErrorResponse(
10548                ResponseValue::from_response(response).await?,
10549            )),
10550            _ => Err(Error::UnexpectedResponse(response)),
10551        }
10552    }
10553
10554    ///Get remote configuration
10555    ///
10556    ///Returns the key/value settings for a single remote.
10557    ///
10558    ///Sends a `POST` request to `/config/get`
10559    ///
10560    ///Arguments:
10561    /// - `async_`: Run the command asynchronously. Returns a job id
10562    ///   immediately.
10563    /// - `group`: Assign the request to a custom stats group.
10564    /// - `name`: Name of the remote configuration to fetch.
10565    pub async fn config_get<'a>(
10566        &'a self,
10567        async_: Option<bool>,
10568        group: Option<&'a str>,
10569        name: &'a str,
10570    ) -> Result<ResponseValue<types::ConfigGetResponse>, Error<types::RcError>> {
10571        let url = format!("{}/config/get", self.baseurl,);
10572        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10573        header_map.append(
10574            ::reqwest::header::HeaderName::from_static("api-version"),
10575            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10576        );
10577        #[allow(unused_mut)]
10578        let mut request = self
10579            .client
10580            .post(url)
10581            .header(
10582                ::reqwest::header::ACCEPT,
10583                ::reqwest::header::HeaderValue::from_static("application/json"),
10584            )
10585            .query(&progenitor_client::QueryParam::new("_async", &async_))
10586            .query(&progenitor_client::QueryParam::new("_group", &group))
10587            .query(&progenitor_client::QueryParam::new("name", &name))
10588            .headers(header_map)
10589            .build()?;
10590        let info = OperationInfo {
10591            operation_id: "config_get",
10592        };
10593        self.pre(&mut request, &info).await?;
10594        let result = self.exec(request, &info).await;
10595        self.post(&result, &info).await?;
10596        let response = result?;
10597        match response.status().as_u16() {
10598            200u16 => ResponseValue::from_response(response).await,
10599            400u16..=499u16 => Err(Error::ErrorResponse(
10600                ResponseValue::from_response(response).await?,
10601            )),
10602            500u16..=599u16 => Err(Error::ErrorResponse(
10603                ResponseValue::from_response(response).await?,
10604            )),
10605            _ => Err(Error::UnexpectedResponse(response)),
10606        }
10607    }
10608
10609    ///List configured remotes
10610    ///
10611    ///Returns the names of all remotes defined in the config file.
10612    ///
10613    ///Sends a `POST` request to `/config/listremotes`
10614    ///
10615    ///Arguments:
10616    /// - `async_`: Run the command asynchronously. Returns a job id
10617    ///   immediately.
10618    /// - `group`: Assign the request to a custom stats group.
10619    pub async fn config_listremotes<'a>(
10620        &'a self,
10621        async_: Option<bool>,
10622        group: Option<&'a str>,
10623    ) -> Result<ResponseValue<types::ConfigListremotesResponse>, Error<types::RcError>> {
10624        let url = format!("{}/config/listremotes", self.baseurl,);
10625        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10626        header_map.append(
10627            ::reqwest::header::HeaderName::from_static("api-version"),
10628            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10629        );
10630        #[allow(unused_mut)]
10631        let mut request = self
10632            .client
10633            .post(url)
10634            .header(
10635                ::reqwest::header::ACCEPT,
10636                ::reqwest::header::HeaderValue::from_static("application/json"),
10637            )
10638            .query(&progenitor_client::QueryParam::new("_async", &async_))
10639            .query(&progenitor_client::QueryParam::new("_group", &group))
10640            .headers(header_map)
10641            .build()?;
10642        let info = OperationInfo {
10643            operation_id: "config_listremotes",
10644        };
10645        self.pre(&mut request, &info).await?;
10646        let result = self.exec(request, &info).await;
10647        self.post(&result, &info).await?;
10648        let response = result?;
10649        match response.status().as_u16() {
10650            200u16 => ResponseValue::from_response(response).await,
10651            400u16..=499u16 => Err(Error::ErrorResponse(
10652                ResponseValue::from_response(response).await?,
10653            )),
10654            500u16..=599u16 => Err(Error::ErrorResponse(
10655                ResponseValue::from_response(response).await?,
10656            )),
10657            _ => Err(Error::UnexpectedResponse(response)),
10658        }
10659    }
10660
10661    ///Update remote secrets
10662    ///
10663    ///Sets obscured password fields for a remote configuration.
10664    ///
10665    ///Sends a `POST` request to `/config/password`
10666    ///
10667    ///Arguments:
10668    /// - `async_`: Run the command asynchronously. Returns a job id
10669    ///   immediately.
10670    /// - `group`: Assign the request to a custom stats group.
10671    /// - `name`: Name of the remote whose secrets should be updated.
10672    /// - `parameters`: JSON object of password answers, typically including
10673    ///   `pass`.
10674    pub async fn config_password<'a>(
10675        &'a self,
10676        async_: Option<bool>,
10677        group: Option<&'a str>,
10678        name: &'a str,
10679        parameters: &'a str,
10680    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10681        let url = format!("{}/config/password", self.baseurl,);
10682        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10683        header_map.append(
10684            ::reqwest::header::HeaderName::from_static("api-version"),
10685            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10686        );
10687        #[allow(unused_mut)]
10688        let mut request = self
10689            .client
10690            .post(url)
10691            .header(
10692                ::reqwest::header::ACCEPT,
10693                ::reqwest::header::HeaderValue::from_static("application/json"),
10694            )
10695            .query(&progenitor_client::QueryParam::new("_async", &async_))
10696            .query(&progenitor_client::QueryParam::new("_group", &group))
10697            .query(&progenitor_client::QueryParam::new("name", &name))
10698            .query(&progenitor_client::QueryParam::new(
10699                "parameters",
10700                &parameters,
10701            ))
10702            .headers(header_map)
10703            .build()?;
10704        let info = OperationInfo {
10705            operation_id: "config_password",
10706        };
10707        self.pre(&mut request, &info).await?;
10708        let result = self.exec(request, &info).await;
10709        self.post(&result, &info).await?;
10710        let response = result?;
10711        match response.status().as_u16() {
10712            200u16 => Ok(ResponseValue::empty(response)),
10713            400u16..=499u16 => Err(Error::ErrorResponse(
10714                ResponseValue::from_response(response).await?,
10715            )),
10716            500u16..=599u16 => Err(Error::ErrorResponse(
10717                ResponseValue::from_response(response).await?,
10718            )),
10719            _ => Err(Error::UnexpectedResponse(response)),
10720        }
10721    }
10722
10723    ///Show config paths
10724    ///
10725    ///Returns the paths to the config file, cache directory, and temporary
10726    /// directory.
10727    ///
10728    ///Sends a `POST` request to `/config/paths`
10729    ///
10730    ///Arguments:
10731    /// - `async_`: Run the command asynchronously. Returns a job id
10732    ///   immediately.
10733    /// - `group`: Assign the request to a custom stats group.
10734    pub async fn config_paths<'a>(
10735        &'a self,
10736        async_: Option<bool>,
10737        group: Option<&'a str>,
10738    ) -> Result<ResponseValue<types::ConfigPathsResponse>, Error<types::RcError>> {
10739        let url = format!("{}/config/paths", self.baseurl,);
10740        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10741        header_map.append(
10742            ::reqwest::header::HeaderName::from_static("api-version"),
10743            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10744        );
10745        #[allow(unused_mut)]
10746        let mut request = self
10747            .client
10748            .post(url)
10749            .header(
10750                ::reqwest::header::ACCEPT,
10751                ::reqwest::header::HeaderValue::from_static("application/json"),
10752            )
10753            .query(&progenitor_client::QueryParam::new("_async", &async_))
10754            .query(&progenitor_client::QueryParam::new("_group", &group))
10755            .headers(header_map)
10756            .build()?;
10757        let info = OperationInfo {
10758            operation_id: "config_paths",
10759        };
10760        self.pre(&mut request, &info).await?;
10761        let result = self.exec(request, &info).await;
10762        self.post(&result, &info).await?;
10763        let response = result?;
10764        match response.status().as_u16() {
10765            200u16 => ResponseValue::from_response(response).await,
10766            400u16..=499u16 => Err(Error::ErrorResponse(
10767                ResponseValue::from_response(response).await?,
10768            )),
10769            500u16..=599u16 => Err(Error::ErrorResponse(
10770                ResponseValue::from_response(response).await?,
10771            )),
10772            _ => Err(Error::UnexpectedResponse(response)),
10773        }
10774    }
10775
10776    ///List backend providers
10777    ///
10778    ///Returns metadata describing each supported storage provider.
10779    ///
10780    ///Sends a `POST` request to `/config/providers`
10781    ///
10782    ///Arguments:
10783    /// - `async_`: Run the command asynchronously. Returns a job id
10784    ///   immediately.
10785    /// - `group`: Assign the request to a custom stats group.
10786    pub async fn config_providers<'a>(
10787        &'a self,
10788        async_: Option<bool>,
10789        group: Option<&'a str>,
10790    ) -> Result<ResponseValue<types::ConfigProvidersResponse>, Error<types::RcError>> {
10791        let url = format!("{}/config/providers", self.baseurl,);
10792        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10793        header_map.append(
10794            ::reqwest::header::HeaderName::from_static("api-version"),
10795            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10796        );
10797        #[allow(unused_mut)]
10798        let mut request = self
10799            .client
10800            .post(url)
10801            .header(
10802                ::reqwest::header::ACCEPT,
10803                ::reqwest::header::HeaderValue::from_static("application/json"),
10804            )
10805            .query(&progenitor_client::QueryParam::new("_async", &async_))
10806            .query(&progenitor_client::QueryParam::new("_group", &group))
10807            .headers(header_map)
10808            .build()?;
10809        let info = OperationInfo {
10810            operation_id: "config_providers",
10811        };
10812        self.pre(&mut request, &info).await?;
10813        let result = self.exec(request, &info).await;
10814        self.post(&result, &info).await?;
10815        let response = result?;
10816        match response.status().as_u16() {
10817            200u16 => ResponseValue::from_response(response).await,
10818            400u16..=499u16 => Err(Error::ErrorResponse(
10819                ResponseValue::from_response(response).await?,
10820            )),
10821            500u16..=599u16 => Err(Error::ErrorResponse(
10822                ResponseValue::from_response(response).await?,
10823            )),
10824            _ => Err(Error::UnexpectedResponse(response)),
10825        }
10826    }
10827
10828    ///Set config path
10829    ///
10830    ///Points rclone at a specific `rclone.conf` file.
10831    ///
10832    ///Sends a `POST` request to `/config/setpath`
10833    ///
10834    ///Arguments:
10835    /// - `async_`: Run the command asynchronously. Returns a job id
10836    ///   immediately.
10837    /// - `group`: Assign the request to a custom stats group.
10838    /// - `path`: Absolute path to the `rclone.conf` file that rclone should
10839    ///   use.
10840    pub async fn config_setpath<'a>(
10841        &'a self,
10842        async_: Option<bool>,
10843        group: Option<&'a str>,
10844        path: &'a str,
10845    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10846        let url = format!("{}/config/setpath", self.baseurl,);
10847        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10848        header_map.append(
10849            ::reqwest::header::HeaderName::from_static("api-version"),
10850            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10851        );
10852        #[allow(unused_mut)]
10853        let mut request = self
10854            .client
10855            .post(url)
10856            .header(
10857                ::reqwest::header::ACCEPT,
10858                ::reqwest::header::HeaderValue::from_static("application/json"),
10859            )
10860            .query(&progenitor_client::QueryParam::new("_async", &async_))
10861            .query(&progenitor_client::QueryParam::new("_group", &group))
10862            .query(&progenitor_client::QueryParam::new("path", &path))
10863            .headers(header_map)
10864            .build()?;
10865        let info = OperationInfo {
10866            operation_id: "config_setpath",
10867        };
10868        self.pre(&mut request, &info).await?;
10869        let result = self.exec(request, &info).await;
10870        self.post(&result, &info).await?;
10871        let response = result?;
10872        match response.status().as_u16() {
10873            200u16 => Ok(ResponseValue::empty(response)),
10874            400u16..=499u16 => Err(Error::ErrorResponse(
10875                ResponseValue::from_response(response).await?,
10876            )),
10877            500u16..=599u16 => Err(Error::ErrorResponse(
10878                ResponseValue::from_response(response).await?,
10879            )),
10880            _ => Err(Error::UnexpectedResponse(response)),
10881        }
10882    }
10883
10884    ///Unlock encrypted config
10885    ///
10886    ///Unlocks the configuration file using the provided password.
10887    ///
10888    ///Sends a `POST` request to `/config/unlock`
10889    ///
10890    ///Arguments:
10891    /// - `async_`: Run the command asynchronously. Returns a job id
10892    ///   immediately.
10893    /// - `group`: Assign the request to a custom stats group.
10894    /// - `config_password`: Password used to unlock an encrypted config file.
10895    pub async fn config_unlock<'a>(
10896        &'a self,
10897        async_: Option<bool>,
10898        group: Option<&'a str>,
10899        config_password: &'a str,
10900    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10901        let url = format!("{}/config/unlock", self.baseurl,);
10902        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10903        header_map.append(
10904            ::reqwest::header::HeaderName::from_static("api-version"),
10905            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10906        );
10907        #[allow(unused_mut)]
10908        let mut request = self
10909            .client
10910            .post(url)
10911            .header(
10912                ::reqwest::header::ACCEPT,
10913                ::reqwest::header::HeaderValue::from_static("application/json"),
10914            )
10915            .query(&progenitor_client::QueryParam::new("_async", &async_))
10916            .query(&progenitor_client::QueryParam::new("_group", &group))
10917            .query(&progenitor_client::QueryParam::new(
10918                "configPassword",
10919                &config_password,
10920            ))
10921            .headers(header_map)
10922            .build()?;
10923        let info = OperationInfo {
10924            operation_id: "config_unlock",
10925        };
10926        self.pre(&mut request, &info).await?;
10927        let result = self.exec(request, &info).await;
10928        self.post(&result, &info).await?;
10929        let response = result?;
10930        match response.status().as_u16() {
10931            200u16 => Ok(ResponseValue::empty(response)),
10932            400u16..=499u16 => Err(Error::ErrorResponse(
10933                ResponseValue::from_response(response).await?,
10934            )),
10935            500u16..=599u16 => Err(Error::ErrorResponse(
10936                ResponseValue::from_response(response).await?,
10937            )),
10938            _ => Err(Error::UnexpectedResponse(response)),
10939        }
10940    }
10941
10942    ///Update remote configuration
10943    ///
10944    ///Updates an existing remote with new parameter values.
10945    ///
10946    ///Sends a `POST` request to `/config/update`
10947    ///
10948    ///Arguments:
10949    /// - `async_`: Run the command asynchronously. Returns a job id
10950    ///   immediately.
10951    /// - `group`: Assign the request to a custom stats group.
10952    /// - `name`: Name of the remote configuration to update.
10953    /// - `opt`: Optional JSON object controlling update behaviour (e.g.
10954    ///   `obscure`, `continue`).
10955    /// - `parameters`: JSON object of configuration key/value pairs to apply to
10956    ///   the remote.
10957    pub async fn config_update<'a>(
10958        &'a self,
10959        async_: Option<bool>,
10960        group: Option<&'a str>,
10961        name: &'a str,
10962        opt: Option<&'a str>,
10963        parameters: &'a str,
10964    ) -> Result<
10965        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10966        Error<types::RcError>,
10967    > {
10968        let url = format!("{}/config/update", self.baseurl,);
10969        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10970        header_map.append(
10971            ::reqwest::header::HeaderName::from_static("api-version"),
10972            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10973        );
10974        #[allow(unused_mut)]
10975        let mut request = self
10976            .client
10977            .post(url)
10978            .header(
10979                ::reqwest::header::ACCEPT,
10980                ::reqwest::header::HeaderValue::from_static("application/json"),
10981            )
10982            .query(&progenitor_client::QueryParam::new("_async", &async_))
10983            .query(&progenitor_client::QueryParam::new("_group", &group))
10984            .query(&progenitor_client::QueryParam::new("name", &name))
10985            .query(&progenitor_client::QueryParam::new("opt", &opt))
10986            .query(&progenitor_client::QueryParam::new(
10987                "parameters",
10988                &parameters,
10989            ))
10990            .headers(header_map)
10991            .build()?;
10992        let info = OperationInfo {
10993            operation_id: "config_update",
10994        };
10995        self.pre(&mut request, &info).await?;
10996        let result = self.exec(request, &info).await;
10997        self.post(&result, &info).await?;
10998        let response = result?;
10999        match response.status().as_u16() {
11000            200u16 => ResponseValue::from_response(response).await,
11001            400u16..=499u16 => Err(Error::ErrorResponse(
11002                ResponseValue::from_response(response).await?,
11003            )),
11004            500u16..=599u16 => Err(Error::ErrorResponse(
11005                ResponseValue::from_response(response).await?,
11006            )),
11007            _ => Err(Error::UnexpectedResponse(response)),
11008        }
11009    }
11010
11011    ///Report rclone version
11012    ///
11013    ///Returns the running rclone version, build metadata, and Go runtime
11014    /// details.
11015    ///
11016    ///Sends a `POST` request to `/core/version`
11017    ///
11018    ///Arguments:
11019    /// - `async_`: Run the command asynchronously. Returns a job id
11020    ///   immediately.
11021    /// - `group`: Assign the request to a custom stats group.
11022    pub async fn core_version<'a>(
11023        &'a self,
11024        async_: Option<bool>,
11025        group: Option<&'a str>,
11026    ) -> Result<ResponseValue<types::CoreVersionResponse>, Error<types::RcError>> {
11027        let url = format!("{}/core/version", self.baseurl,);
11028        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11029        header_map.append(
11030            ::reqwest::header::HeaderName::from_static("api-version"),
11031            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11032        );
11033        #[allow(unused_mut)]
11034        let mut request = self
11035            .client
11036            .post(url)
11037            .header(
11038                ::reqwest::header::ACCEPT,
11039                ::reqwest::header::HeaderValue::from_static("application/json"),
11040            )
11041            .query(&progenitor_client::QueryParam::new("_async", &async_))
11042            .query(&progenitor_client::QueryParam::new("_group", &group))
11043            .headers(header_map)
11044            .build()?;
11045        let info = OperationInfo {
11046            operation_id: "core_version",
11047        };
11048        self.pre(&mut request, &info).await?;
11049        let result = self.exec(request, &info).await;
11050        self.post(&result, &info).await?;
11051        let response = result?;
11052        match response.status().as_u16() {
11053            200u16 => ResponseValue::from_response(response).await,
11054            400u16..=499u16 => Err(Error::ErrorResponse(
11055                ResponseValue::from_response(response).await?,
11056            )),
11057            500u16..=599u16 => Err(Error::ErrorResponse(
11058                ResponseValue::from_response(response).await?,
11059            )),
11060            _ => Err(Error::UnexpectedResponse(response)),
11061        }
11062    }
11063
11064    ///Current stats snapshot
11065    ///
11066    ///Returns active transfer statistics including bytes transferred, speed,
11067    /// and error counts.
11068    ///
11069    ///Sends a `POST` request to `/core/stats`
11070    ///
11071    ///Arguments:
11072    /// - `async_`: Run the command asynchronously. Returns a job id
11073    ///   immediately.
11074    /// - `group`: Assign the request to a custom stats group.
11075    /// - `group`: Stats group identifier to return a snapshot for. Leave unset
11076    ///   to include all groups.
11077    /// - `short`: When true, omit the `transferring` and `checking` arrays from
11078    ///   the response.
11079    pub async fn core_stats<'a>(
11080        &'a self,
11081        async_: Option<bool>,
11082        _group: Option<&'a str>,
11083        group: Option<&'a str>,
11084        short: Option<bool>
11085    ) -> Result<ResponseValue<types::CoreStatsResponse>, Error<types::RcError>> {
11086        let url = format!("{}/core/stats", self.baseurl,);
11087        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11088        header_map.append(
11089            ::reqwest::header::HeaderName::from_static("api-version"),
11090            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11091        );
11092        #[allow(unused_mut)]
11093        let mut request = self
11094            .client
11095            .post(url)
11096            .header(
11097                ::reqwest::header::ACCEPT,
11098                ::reqwest::header::HeaderValue::from_static("application/json"),
11099            )
11100            .query(&progenitor_client::QueryParam::new("_async", &async_))
11101            .query(&progenitor_client::QueryParam::new("_group", &group))
11102            .query(&progenitor_client::QueryParam::new("group", &group))
11103            .query(&progenitor_client::QueryParam::new("short", &short))
11104            .headers(header_map)
11105            .build()?;
11106        let info = OperationInfo {
11107            operation_id: "core_stats",
11108        };
11109        self.pre(&mut request, &info).await?;
11110        let result = self.exec(request, &info).await;
11111        self.post(&result, &info).await?;
11112        let response = result?;
11113        match response.status().as_u16() {
11114            200u16 => ResponseValue::from_response(response).await,
11115            400u16..=499u16 => Err(Error::ErrorResponse(
11116                ResponseValue::from_response(response).await?,
11117            )),
11118            500u16..=599u16 => Err(Error::ErrorResponse(
11119                ResponseValue::from_response(response).await?,
11120            )),
11121            _ => Err(Error::UnexpectedResponse(response)),
11122        }
11123    }
11124
11125    ///Run batch of commands
11126    ///
11127    ///Run a batch of rclone rc commands concurrently.
11128    ///
11129    ///Sends a `POST` request to `/job/batch`
11130    ///
11131    ///Arguments:
11132    /// - `async_`: Run the command asynchronously. Returns a job id
11133    ///   immediately.
11134    /// - `concurrency`: Do this many commands concurrently. Defaults to
11135    ///   --transfers if not set.
11136    /// - `inputs`: List of inputs to the commands with an extra _path
11137    ///   parameter.
11138    /// - `body`
11139    pub async fn job_batch<'a>(
11140        &'a self,
11141        async_: Option<bool>,
11142        concurrency: Option<i64>,
11143        inputs: Option<&'a ::std::vec::Vec<types::JobBatchInputsItem>>,
11144        body: &'a types::JobBatchRequest,
11145    ) -> Result<ResponseValue<types::JobBatchResponse>, Error<types::RcError>> {
11146        let url = format!("{}/job/batch", self.baseurl,);
11147        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11148        header_map.append(
11149            ::reqwest::header::HeaderName::from_static("api-version"),
11150            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11151        );
11152        #[allow(unused_mut)]
11153        let mut request = self
11154            .client
11155            .post(url)
11156            .header(
11157                ::reqwest::header::ACCEPT,
11158                ::reqwest::header::HeaderValue::from_static("application/json"),
11159            )
11160            .json(&body)
11161            .query(&progenitor_client::QueryParam::new("_async", &async_))
11162            .query(&progenitor_client::QueryParam::new(
11163                "concurrency",
11164                &concurrency,
11165            ))
11166            .query(&progenitor_client::QueryParam::new("inputs", &inputs))
11167            .headers(header_map)
11168            .build()?;
11169        let info = OperationInfo {
11170            operation_id: "job_batch",
11171        };
11172        self.pre(&mut request, &info).await?;
11173        let result = self.exec(request, &info).await;
11174        self.post(&result, &info).await?;
11175        let response = result?;
11176        match response.status().as_u16() {
11177            200u16 => ResponseValue::from_response(response).await,
11178            400u16..=499u16 => Err(Error::ErrorResponse(
11179                ResponseValue::from_response(response).await?,
11180            )),
11181            500u16..=599u16 => Err(Error::ErrorResponse(
11182                ResponseValue::from_response(response).await?,
11183            )),
11184            _ => Err(Error::UnexpectedResponse(response)),
11185        }
11186    }
11187
11188    ///List jobs
11189    ///
11190    ///Returns identifiers of active and recently completed asynchronous jobs.
11191    ///
11192    ///Sends a `POST` request to `/job/list`
11193    ///
11194    ///Arguments:
11195    /// - `async_`: Run the command asynchronously. Returns a job id
11196    ///   immediately.
11197    pub async fn job_list<'a>(
11198        &'a self,
11199        async_: Option<bool>,
11200    ) -> Result<ResponseValue<types::JobListResponse>, Error<types::RcError>> {
11201        let url = format!("{}/job/list", self.baseurl,);
11202        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11203        header_map.append(
11204            ::reqwest::header::HeaderName::from_static("api-version"),
11205            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11206        );
11207        #[allow(unused_mut)]
11208        let mut request = self
11209            .client
11210            .post(url)
11211            .header(
11212                ::reqwest::header::ACCEPT,
11213                ::reqwest::header::HeaderValue::from_static("application/json"),
11214            )
11215            .query(&progenitor_client::QueryParam::new("_async", &async_))
11216            .headers(header_map)
11217            .build()?;
11218        let info = OperationInfo {
11219            operation_id: "job_list",
11220        };
11221        self.pre(&mut request, &info).await?;
11222        let result = self.exec(request, &info).await;
11223        self.post(&result, &info).await?;
11224        let response = result?;
11225        match response.status().as_u16() {
11226            200u16 => ResponseValue::from_response(response).await,
11227            400u16..=499u16 => Err(Error::ErrorResponse(
11228                ResponseValue::from_response(response).await?,
11229            )),
11230            500u16..=599u16 => Err(Error::ErrorResponse(
11231                ResponseValue::from_response(response).await?,
11232            )),
11233            _ => Err(Error::UnexpectedResponse(response)),
11234        }
11235    }
11236
11237    ///Get job status
11238    ///
11239    ///Returns timing, success state, output, and progress for a specific job.
11240    ///
11241    ///Sends a `POST` request to `/job/status`
11242    ///
11243    ///Arguments:
11244    /// - `async_`: Run the command asynchronously. Returns a job id
11245    ///   immediately.
11246    /// - `jobid`: Numeric identifier of the job to query, as returned from an
11247    ///   async call.
11248    pub async fn job_status<'a>(
11249        &'a self,
11250        async_: Option<bool>,
11251        jobid: f64,
11252    ) -> Result<ResponseValue<types::JobStatusResponse>, Error<types::RcError>> {
11253        let url = format!("{}/job/status", self.baseurl,);
11254        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11255        header_map.append(
11256            ::reqwest::header::HeaderName::from_static("api-version"),
11257            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11258        );
11259        #[allow(unused_mut)]
11260        let mut request = self
11261            .client
11262            .post(url)
11263            .header(
11264                ::reqwest::header::ACCEPT,
11265                ::reqwest::header::HeaderValue::from_static("application/json"),
11266            )
11267            .query(&progenitor_client::QueryParam::new("_async", &async_))
11268            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
11269            .headers(header_map)
11270            .build()?;
11271        let info = OperationInfo {
11272            operation_id: "job_status",
11273        };
11274        self.pre(&mut request, &info).await?;
11275        let result = self.exec(request, &info).await;
11276        self.post(&result, &info).await?;
11277        let response = result?;
11278        match response.status().as_u16() {
11279            200u16 => ResponseValue::from_response(response).await,
11280            400u16..=499u16 => Err(Error::ErrorResponse(
11281                ResponseValue::from_response(response).await?,
11282            )),
11283            500u16..=599u16 => Err(Error::ErrorResponse(
11284                ResponseValue::from_response(response).await?,
11285            )),
11286            _ => Err(Error::UnexpectedResponse(response)),
11287        }
11288    }
11289
11290    ///Stop job
11291    ///
11292    ///Attempts to cancel a running job by ID.
11293    ///
11294    ///Sends a `POST` request to `/job/stop`
11295    ///
11296    ///Arguments:
11297    /// - `async_`: Run the command asynchronously. Returns a job id
11298    ///   immediately.
11299    /// - `jobid`: Numeric identifier of the job to cancel.
11300    pub async fn job_stop<'a>(
11301        &'a self,
11302        async_: Option<bool>,
11303        jobid: f64,
11304    ) -> Result<
11305        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11306        Error<types::RcError>,
11307    > {
11308        let url = format!("{}/job/stop", self.baseurl,);
11309        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11310        header_map.append(
11311            ::reqwest::header::HeaderName::from_static("api-version"),
11312            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11313        );
11314        #[allow(unused_mut)]
11315        let mut request = self
11316            .client
11317            .post(url)
11318            .header(
11319                ::reqwest::header::ACCEPT,
11320                ::reqwest::header::HeaderValue::from_static("application/json"),
11321            )
11322            .query(&progenitor_client::QueryParam::new("_async", &async_))
11323            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
11324            .headers(header_map)
11325            .build()?;
11326        let info = OperationInfo {
11327            operation_id: "job_stop",
11328        };
11329        self.pre(&mut request, &info).await?;
11330        let result = self.exec(request, &info).await;
11331        self.post(&result, &info).await?;
11332        let response = result?;
11333        match response.status().as_u16() {
11334            200u16 => ResponseValue::from_response(response).await,
11335            400u16..=499u16 => Err(Error::ErrorResponse(
11336                ResponseValue::from_response(response).await?,
11337            )),
11338            500u16..=599u16 => Err(Error::ErrorResponse(
11339                ResponseValue::from_response(response).await?,
11340            )),
11341            _ => Err(Error::UnexpectedResponse(response)),
11342        }
11343    }
11344
11345    ///Stop jobs in group
11346    ///
11347    ///Cancels all active jobs associated with the provided stats group.
11348    ///
11349    ///Sends a `POST` request to `/job/stopgroup`
11350    ///
11351    ///Arguments:
11352    /// - `async_`: Run the command asynchronously. Returns a job id
11353    ///   immediately.
11354    /// - `group`: Stats group name whose active jobs should be stopped.
11355    pub async fn job_stopgroup<'a>(
11356        &'a self,
11357        async_: Option<bool>,
11358        group: &'a str,
11359    ) -> Result<
11360        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11361        Error<types::RcError>,
11362    > {
11363        let url = format!("{}/job/stopgroup", self.baseurl,);
11364        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11365        header_map.append(
11366            ::reqwest::header::HeaderName::from_static("api-version"),
11367            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11368        );
11369        #[allow(unused_mut)]
11370        let mut request = self
11371            .client
11372            .post(url)
11373            .header(
11374                ::reqwest::header::ACCEPT,
11375                ::reqwest::header::HeaderValue::from_static("application/json"),
11376            )
11377            .query(&progenitor_client::QueryParam::new("_async", &async_))
11378            .query(&progenitor_client::QueryParam::new("group", &group))
11379            .headers(header_map)
11380            .build()?;
11381        let info = OperationInfo {
11382            operation_id: "job_stopgroup",
11383        };
11384        self.pre(&mut request, &info).await?;
11385        let result = self.exec(request, &info).await;
11386        self.post(&result, &info).await?;
11387        let response = result?;
11388        match response.status().as_u16() {
11389            200u16 => ResponseValue::from_response(response).await,
11390            400u16..=499u16 => Err(Error::ErrorResponse(
11391                ResponseValue::from_response(response).await?,
11392            )),
11393            500u16..=599u16 => Err(Error::ErrorResponse(
11394                ResponseValue::from_response(response).await?,
11395            )),
11396            _ => Err(Error::UnexpectedResponse(response)),
11397        }
11398    }
11399
11400    ///List objects
11401    ///
11402    ///Lists objects and directories for a remote path, returning the same
11403    /// fields as `rclone lsjson`.
11404    ///
11405    ///Sends a `POST` request to `/operations/list`
11406    ///
11407    ///Arguments:
11408    /// - `async_`: Run the command asynchronously. Returns a job id
11409    ///   immediately.
11410    /// - `group`: Assign the request to a custom stats group.
11411    /// - `dirs_only`: Set to true to return only directory entries.
11412    /// - `files_only`: Set to true to return only file entries.
11413    /// - `fs`: Remote name or path to list, for example `drive:`.
11414    /// - `hash_types`: Specify one or more hash algorithms to include when
11415    ///   `showHash` is true (e.g. `md5`).
11416    /// - `metadata`: Set to true to include backend-provided metadata maps.
11417    /// - `no_mime_type`: Set to true to omit MIME type detection.
11418    /// - `no_mod_time`: Set to true to omit modification times for faster
11419    ///   listings on some backends.
11420    /// - `opt`: Optional JSON-encoded object of listing flags (e.g. `{
11421    ///   "recurse": true, "showHash": true }`).
11422    /// - `recurse`: Set to true to list directories recursively.
11423    /// - `remote`: Directory path within `fs` to list; leave empty to target
11424    ///   the root.
11425    /// - `show_encrypted`: Set to true to include encrypted names when using
11426    ///   crypt remotes.
11427    /// - `show_hash`: Set to true to include hash digests for each entry.
11428    /// - `show_orig_i_ds`: Set to true to include original backend identifiers
11429    ///   where available.
11430    pub async fn operations_list<'a>(
11431        &'a self,
11432        async_: Option<bool>,
11433        group: Option<&'a str>,
11434        dirs_only: Option<bool>,
11435        files_only: Option<bool>,
11436        fs: &'a str,
11437        hash_types: Option<&'a ::std::vec::Vec<::std::string::String>>,
11438        metadata: Option<bool>,
11439        no_mime_type: Option<bool>,
11440        no_mod_time: Option<bool>,
11441        opt: Option<&'a str>,
11442        recurse: Option<bool>,
11443        remote: &'a str,
11444        show_encrypted: Option<bool>,
11445        show_hash: Option<bool>,
11446        show_orig_i_ds: Option<bool>,
11447    ) -> Result<ResponseValue<types::OperationsListResponse>, Error<types::RcError>> {
11448        let url = format!("{}/operations/list", self.baseurl,);
11449        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11450        header_map.append(
11451            ::reqwest::header::HeaderName::from_static("api-version"),
11452            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11453        );
11454        #[allow(unused_mut)]
11455        let mut request = self
11456            .client
11457            .post(url)
11458            .header(
11459                ::reqwest::header::ACCEPT,
11460                ::reqwest::header::HeaderValue::from_static("application/json"),
11461            )
11462            .query(&progenitor_client::QueryParam::new("_async", &async_))
11463            .query(&progenitor_client::QueryParam::new("_group", &group))
11464            .query(&progenitor_client::QueryParam::new("dirsOnly", &dirs_only))
11465            .query(&progenitor_client::QueryParam::new(
11466                "filesOnly",
11467                &files_only,
11468            ))
11469            .query(&progenitor_client::QueryParam::new("fs", &fs))
11470            .query(&progenitor_client::QueryParam::new(
11471                "hashTypes",
11472                &hash_types,
11473            ))
11474            .query(&progenitor_client::QueryParam::new("metadata", &metadata))
11475            .query(&progenitor_client::QueryParam::new(
11476                "noMimeType",
11477                &no_mime_type,
11478            ))
11479            .query(&progenitor_client::QueryParam::new(
11480                "noModTime",
11481                &no_mod_time,
11482            ))
11483            .query(&progenitor_client::QueryParam::new("opt", &opt))
11484            .query(&progenitor_client::QueryParam::new("recurse", &recurse))
11485            .query(&progenitor_client::QueryParam::new("remote", &remote))
11486            .query(&progenitor_client::QueryParam::new(
11487                "showEncrypted",
11488                &show_encrypted,
11489            ))
11490            .query(&progenitor_client::QueryParam::new("showHash", &show_hash))
11491            .query(&progenitor_client::QueryParam::new(
11492                "showOrigIDs",
11493                &show_orig_i_ds,
11494            ))
11495            .headers(header_map)
11496            .build()?;
11497        let info = OperationInfo {
11498            operation_id: "operations_list",
11499        };
11500        self.pre(&mut request, &info).await?;
11501        let result = self.exec(request, &info).await;
11502        self.post(&result, &info).await?;
11503        let response = result?;
11504        match response.status().as_u16() {
11505            200u16 => ResponseValue::from_response(response).await,
11506            400u16..=499u16 => Err(Error::ErrorResponse(
11507                ResponseValue::from_response(response).await?,
11508            )),
11509            500u16..=599u16 => Err(Error::ErrorResponse(
11510                ResponseValue::from_response(response).await?,
11511            )),
11512            _ => Err(Error::UnexpectedResponse(response)),
11513        }
11514    }
11515
11516    ///Stat an object
11517    ///
11518    ///Returns metadata for a single file or directory, mirroring `rclone
11519    /// lsjson` on one entry.
11520    ///
11521    ///Sends a `POST` request to `/operations/stat`
11522    ///
11523    ///Arguments:
11524    /// - `async_`: Run the command asynchronously. Returns a job id
11525    ///   immediately.
11526    /// - `group`: Assign the request to a custom stats group.
11527    /// - `fs`: Remote name or path that contains the item to inspect.
11528    /// - `opt`: Optional JSON object of listing flags, matching those accepted
11529    ///   by `operations/list`.
11530    /// - `remote`: Path to the file or directory within `fs` to describe.
11531    pub async fn operations_stat<'a>(
11532        &'a self,
11533        async_: Option<bool>,
11534        group: Option<&'a str>,
11535        fs: &'a str,
11536        opt: Option<&'a str>,
11537        remote: &'a str,
11538    ) -> Result<ResponseValue<types::OperationsStatResponse>, Error<types::RcError>> {
11539        let url = format!("{}/operations/stat", self.baseurl,);
11540        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11541        header_map.append(
11542            ::reqwest::header::HeaderName::from_static("api-version"),
11543            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11544        );
11545        #[allow(unused_mut)]
11546        let mut request = self
11547            .client
11548            .post(url)
11549            .header(
11550                ::reqwest::header::ACCEPT,
11551                ::reqwest::header::HeaderValue::from_static("application/json"),
11552            )
11553            .query(&progenitor_client::QueryParam::new("_async", &async_))
11554            .query(&progenitor_client::QueryParam::new("_group", &group))
11555            .query(&progenitor_client::QueryParam::new("fs", &fs))
11556            .query(&progenitor_client::QueryParam::new("opt", &opt))
11557            .query(&progenitor_client::QueryParam::new("remote", &remote))
11558            .headers(header_map)
11559            .build()?;
11560        let info = OperationInfo {
11561            operation_id: "operations_stat",
11562        };
11563        self.pre(&mut request, &info).await?;
11564        let result = self.exec(request, &info).await;
11565        self.post(&result, &info).await?;
11566        let response = result?;
11567        match response.status().as_u16() {
11568            200u16 => ResponseValue::from_response(response).await,
11569            400u16..=499u16 => Err(Error::ErrorResponse(
11570                ResponseValue::from_response(response).await?,
11571            )),
11572            500u16..=599u16 => Err(Error::ErrorResponse(
11573                ResponseValue::from_response(response).await?,
11574            )),
11575            _ => Err(Error::UnexpectedResponse(response)),
11576        }
11577    }
11578
11579    ///Get remote quota
11580    ///
11581    ///Returns storage quota and usage details for the remote, equivalent to
11582    /// `rclone about`.
11583    ///
11584    ///Sends a `POST` request to `/operations/about`
11585    ///
11586    ///Arguments:
11587    /// - `async_`: Run the command asynchronously. Returns a job id
11588    ///   immediately.
11589    /// - `group`: Assign the request to a custom stats group.
11590    /// - `fs`: Remote name or path to query for capacity information.
11591    pub async fn operations_about<'a>(
11592        &'a self,
11593        async_: Option<bool>,
11594        group: Option<&'a str>,
11595        fs: &'a str,
11596    ) -> Result<ResponseValue<types::OperationsAboutResponse>, Error<types::RcError>> {
11597        let url = format!("{}/operations/about", self.baseurl,);
11598        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11599        header_map.append(
11600            ::reqwest::header::HeaderName::from_static("api-version"),
11601            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11602        );
11603        #[allow(unused_mut)]
11604        let mut request = self
11605            .client
11606            .post(url)
11607            .header(
11608                ::reqwest::header::ACCEPT,
11609                ::reqwest::header::HeaderValue::from_static("application/json"),
11610            )
11611            .query(&progenitor_client::QueryParam::new("_async", &async_))
11612            .query(&progenitor_client::QueryParam::new("_group", &group))
11613            .query(&progenitor_client::QueryParam::new("fs", &fs))
11614            .headers(header_map)
11615            .build()?;
11616        let info = OperationInfo {
11617            operation_id: "operations_about",
11618        };
11619        self.pre(&mut request, &info).await?;
11620        let result = self.exec(request, &info).await;
11621        self.post(&result, &info).await?;
11622        let response = result?;
11623        match response.status().as_u16() {
11624            200u16 => ResponseValue::from_response(response).await,
11625            400u16..=499u16 => Err(Error::ErrorResponse(
11626                ResponseValue::from_response(response).await?,
11627            )),
11628            500u16..=599u16 => Err(Error::ErrorResponse(
11629                ResponseValue::from_response(response).await?,
11630            )),
11631            _ => Err(Error::UnexpectedResponse(response)),
11632        }
11633    }
11634
11635    ///Upload files via multipart
11636    ///
11637    ///Accepts multipart/form-data payloads and writes the uploaded files to
11638    /// the specified remote path.
11639    ///
11640    ///Sends a `POST` request to `/operations/uploadfile`
11641    ///
11642    ///Arguments:
11643    /// - `async_`: Run the command asynchronously. Returns a job id
11644    ///   immediately.
11645    /// - `group`: Assign the request to a custom stats group.
11646    /// - `fs`: Remote name or path where the uploaded file should be stored.
11647    /// - `remote`: Destination path within `fs` for the uploaded file.
11648    /// - `body`: Multipart form payload containing one or more files to upload.
11649    pub async fn operations_uploadfile<'a, B: Into<reqwest::Body>>(
11650        &'a self,
11651        async_: Option<bool>,
11652        group: Option<&'a str>,
11653        fs: &'a str,
11654        remote: &'a str,
11655        body: B,
11656    ) -> Result<
11657        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11658        Error<types::RcError>,
11659    > {
11660        let url = format!("{}/operations/uploadfile", self.baseurl,);
11661        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11662        header_map.append(
11663            ::reqwest::header::HeaderName::from_static("api-version"),
11664            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11665        );
11666        #[allow(unused_mut)]
11667        let mut request = self
11668            .client
11669            .post(url)
11670            .header(
11671                ::reqwest::header::ACCEPT,
11672                ::reqwest::header::HeaderValue::from_static("application/json"),
11673            )
11674            .header(
11675                ::reqwest::header::CONTENT_TYPE,
11676                ::reqwest::header::HeaderValue::from_static("application/octet-stream"),
11677            )
11678            .body(body)
11679            .query(&progenitor_client::QueryParam::new("_async", &async_))
11680            .query(&progenitor_client::QueryParam::new("_group", &group))
11681            .query(&progenitor_client::QueryParam::new("fs", &fs))
11682            .query(&progenitor_client::QueryParam::new("remote", &remote))
11683            .headers(header_map)
11684            .build()?;
11685        let info = OperationInfo {
11686            operation_id: "operations_uploadfile",
11687        };
11688        self.pre(&mut request, &info).await?;
11689        let result = self.exec(request, &info).await;
11690        self.post(&result, &info).await?;
11691        let response = result?;
11692        match response.status().as_u16() {
11693            200u16 => ResponseValue::from_response(response).await,
11694            400u16..=499u16 => Err(Error::ErrorResponse(
11695                ResponseValue::from_response(response).await?,
11696            )),
11697            500u16..=599u16 => Err(Error::ErrorResponse(
11698                ResponseValue::from_response(response).await?,
11699            )),
11700            _ => Err(Error::UnexpectedResponse(response)),
11701        }
11702    }
11703
11704    ///Purge directory
11705    ///
11706    ///Deletes a directory or container and all of its contents.
11707    ///
11708    ///Sends a `POST` request to `/operations/purge`
11709    ///
11710    ///Arguments:
11711    /// - `async_`: Run the command asynchronously. Returns a job id
11712    ///   immediately.
11713    /// - `config`: JSON encoded config overrides applied for this call only.
11714    /// - `filter`: JSON encoded filter overrides applied for this call only.
11715    /// - `group`: Assign the request to a custom stats group.
11716    /// - `fs`: Remote name or path from which to remove all contents.
11717    /// - `remote`: Path within `fs` whose contents should be purged.
11718    pub async fn operations_purge<'a>(
11719        &'a self,
11720        async_: Option<bool>,
11721        config: Option<&'a str>,
11722        filter: Option<&'a str>,
11723        group: Option<&'a str>,
11724        fs: &'a str,
11725        remote: &'a str,
11726    ) -> Result<
11727        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11728        Error<types::RcError>,
11729    > {
11730        let url = format!("{}/operations/purge", self.baseurl,);
11731        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11732        header_map.append(
11733            ::reqwest::header::HeaderName::from_static("api-version"),
11734            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11735        );
11736        #[allow(unused_mut)]
11737        let mut request = self
11738            .client
11739            .post(url)
11740            .header(
11741                ::reqwest::header::ACCEPT,
11742                ::reqwest::header::HeaderValue::from_static("application/json"),
11743            )
11744            .query(&progenitor_client::QueryParam::new("_async", &async_))
11745            .query(&progenitor_client::QueryParam::new("_config", &config))
11746            .query(&progenitor_client::QueryParam::new("_filter", &filter))
11747            .query(&progenitor_client::QueryParam::new("_group", &group))
11748            .query(&progenitor_client::QueryParam::new("fs", &fs))
11749            .query(&progenitor_client::QueryParam::new("remote", &remote))
11750            .headers(header_map)
11751            .build()?;
11752        let info = OperationInfo {
11753            operation_id: "operations_purge",
11754        };
11755        self.pre(&mut request, &info).await?;
11756        let result = self.exec(request, &info).await;
11757        self.post(&result, &info).await?;
11758        let response = result?;
11759        match response.status().as_u16() {
11760            200u16 => ResponseValue::from_response(response).await,
11761            400u16..=499u16 => Err(Error::ErrorResponse(
11762                ResponseValue::from_response(response).await?,
11763            )),
11764            500u16..=599u16 => Err(Error::ErrorResponse(
11765                ResponseValue::from_response(response).await?,
11766            )),
11767            _ => Err(Error::UnexpectedResponse(response)),
11768        }
11769    }
11770
11771    ///Create directory
11772    ///
11773    ///Creates the target directory or container if it does not exist.
11774    ///
11775    ///Sends a `POST` request to `/operations/mkdir`
11776    ///
11777    ///Arguments:
11778    /// - `async_`: Run the command asynchronously. Returns a job id
11779    ///   immediately.
11780    /// - `group`: Assign the request to a custom stats group.
11781    /// - `fs`: Remote name or path in which to create a directory.
11782    /// - `remote`: Directory path within `fs` to create.
11783    pub async fn operations_mkdir<'a>(
11784        &'a self,
11785        async_: Option<bool>,
11786        group: Option<&'a str>,
11787        fs: &'a str,
11788        remote: &'a str,
11789    ) -> Result<
11790        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11791        Error<types::RcError>,
11792    > {
11793        let url = format!("{}/operations/mkdir", self.baseurl,);
11794        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11795        header_map.append(
11796            ::reqwest::header::HeaderName::from_static("api-version"),
11797            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11798        );
11799        #[allow(unused_mut)]
11800        let mut request = self
11801            .client
11802            .post(url)
11803            .header(
11804                ::reqwest::header::ACCEPT,
11805                ::reqwest::header::HeaderValue::from_static("application/json"),
11806            )
11807            .query(&progenitor_client::QueryParam::new("_async", &async_))
11808            .query(&progenitor_client::QueryParam::new("_group", &group))
11809            .query(&progenitor_client::QueryParam::new("fs", &fs))
11810            .query(&progenitor_client::QueryParam::new("remote", &remote))
11811            .headers(header_map)
11812            .build()?;
11813        let info = OperationInfo {
11814            operation_id: "operations_mkdir",
11815        };
11816        self.pre(&mut request, &info).await?;
11817        let result = self.exec(request, &info).await;
11818        self.post(&result, &info).await?;
11819        let response = result?;
11820        match response.status().as_u16() {
11821            200u16 => ResponseValue::from_response(response).await,
11822            400u16..=499u16 => Err(Error::ErrorResponse(
11823                ResponseValue::from_response(response).await?,
11824            )),
11825            500u16..=599u16 => Err(Error::ErrorResponse(
11826                ResponseValue::from_response(response).await?,
11827            )),
11828            _ => Err(Error::UnexpectedResponse(response)),
11829        }
11830    }
11831
11832    ///Remove empty directory
11833    ///
11834    ///Deletes an empty directory or container.
11835    ///
11836    ///Sends a `POST` request to `/operations/rmdir`
11837    ///
11838    ///Arguments:
11839    /// - `async_`: Run the command asynchronously. Returns a job id
11840    ///   immediately.
11841    /// - `group`: Assign the request to a custom stats group.
11842    /// - `fs`: Remote name or path containing the directory to remove.
11843    /// - `remote`: Directory path within `fs` to delete.
11844    pub async fn operations_rmdir<'a>(
11845        &'a self,
11846        async_: Option<bool>,
11847        group: Option<&'a str>,
11848        fs: &'a str,
11849        remote: &'a str,
11850    ) -> Result<
11851        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11852        Error<types::RcError>,
11853    > {
11854        let url = format!("{}/operations/rmdir", self.baseurl,);
11855        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11856        header_map.append(
11857            ::reqwest::header::HeaderName::from_static("api-version"),
11858            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11859        );
11860        #[allow(unused_mut)]
11861        let mut request = self
11862            .client
11863            .post(url)
11864            .header(
11865                ::reqwest::header::ACCEPT,
11866                ::reqwest::header::HeaderValue::from_static("application/json"),
11867            )
11868            .query(&progenitor_client::QueryParam::new("_async", &async_))
11869            .query(&progenitor_client::QueryParam::new("_group", &group))
11870            .query(&progenitor_client::QueryParam::new("fs", &fs))
11871            .query(&progenitor_client::QueryParam::new("remote", &remote))
11872            .headers(header_map)
11873            .build()?;
11874        let info = OperationInfo {
11875            operation_id: "operations_rmdir",
11876        };
11877        self.pre(&mut request, &info).await?;
11878        let result = self.exec(request, &info).await;
11879        self.post(&result, &info).await?;
11880        let response = result?;
11881        match response.status().as_u16() {
11882            200u16 => ResponseValue::from_response(response).await,
11883            400u16..=499u16 => Err(Error::ErrorResponse(
11884                ResponseValue::from_response(response).await?,
11885            )),
11886            500u16..=599u16 => Err(Error::ErrorResponse(
11887                ResponseValue::from_response(response).await?,
11888            )),
11889            _ => Err(Error::UnexpectedResponse(response)),
11890        }
11891    }
11892
11893    ///Compare source and destination
11894    ///
11895    ///Compares source and destination trees, reporting matches, differences,
11896    /// and missing files.
11897    ///
11898    ///Sends a `POST` request to `/operations/check`
11899    ///
11900    ///Arguments:
11901    /// - `async_`: Run the command asynchronously. Returns a job id
11902    ///   immediately.
11903    /// - `group`: Assign the request to a custom stats group.
11904    /// - `check_file_fs`: Remote containing the checksum SUM file when using
11905    ///   `checkFileHash`.
11906    /// - `check_file_hash`: Hash name to expect in the supplied SUM file, such
11907    ///   as `md5`.
11908    /// - `check_file_remote`: Path within `checkFileFs` to the checksum SUM
11909    ///   file.
11910    /// - `combined`: Set to true to include a combined summary report in the
11911    ///   response.
11912    /// - `differ`: Set to true to include differing files in the report.
11913    /// - `download`: Set to true to read file contents during comparison
11914    ///   instead of relying on hashes.
11915    /// - `dst_fs`: Destination remote name or path that should match the
11916    ///   source.
11917    /// - `error`: Set to true to include entries that encountered errors.
11918    /// - `match_`: Set to true to include matching files in the report.
11919    /// - `missing_on_dst`: Set to true to report files missing from the
11920    ///   destination.
11921    /// - `missing_on_src`: Set to true to report files missing from the source.
11922    /// - `one_way`: Set to true to only ensure that source files exist on the
11923    ///   destination.
11924    /// - `src_fs`: Source remote name or path to verify, e.g. `drive:`.
11925    pub async fn operations_check<'a>(
11926        &'a self,
11927        async_: Option<bool>,
11928        group: Option<&'a str>,
11929        check_file_fs: Option<&'a str>,
11930        check_file_hash: Option<&'a str>,
11931        check_file_remote: Option<&'a str>,
11932        combined: Option<bool>,
11933        differ: Option<bool>,
11934        download: Option<bool>,
11935        dst_fs: &'a str,
11936        error: Option<bool>,
11937        match_: Option<bool>,
11938        missing_on_dst: Option<bool>,
11939        missing_on_src: Option<bool>,
11940        one_way: Option<bool>,
11941        src_fs: &'a str,
11942    ) -> Result<ResponseValue<types::OperationsCheckResponse>, Error<types::RcError>> {
11943        let url = format!("{}/operations/check", self.baseurl,);
11944        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11945        header_map.append(
11946            ::reqwest::header::HeaderName::from_static("api-version"),
11947            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11948        );
11949        #[allow(unused_mut)]
11950        let mut request = self
11951            .client
11952            .post(url)
11953            .header(
11954                ::reqwest::header::ACCEPT,
11955                ::reqwest::header::HeaderValue::from_static("application/json"),
11956            )
11957            .query(&progenitor_client::QueryParam::new("_async", &async_))
11958            .query(&progenitor_client::QueryParam::new("_group", &group))
11959            .query(&progenitor_client::QueryParam::new(
11960                "checkFileFs",
11961                &check_file_fs,
11962            ))
11963            .query(&progenitor_client::QueryParam::new(
11964                "checkFileHash",
11965                &check_file_hash,
11966            ))
11967            .query(&progenitor_client::QueryParam::new(
11968                "checkFileRemote",
11969                &check_file_remote,
11970            ))
11971            .query(&progenitor_client::QueryParam::new("combined", &combined))
11972            .query(&progenitor_client::QueryParam::new("differ", &differ))
11973            .query(&progenitor_client::QueryParam::new("download", &download))
11974            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
11975            .query(&progenitor_client::QueryParam::new("error", &error))
11976            .query(&progenitor_client::QueryParam::new("match", &match_))
11977            .query(&progenitor_client::QueryParam::new(
11978                "missingOnDst",
11979                &missing_on_dst,
11980            ))
11981            .query(&progenitor_client::QueryParam::new(
11982                "missingOnSrc",
11983                &missing_on_src,
11984            ))
11985            .query(&progenitor_client::QueryParam::new("oneWay", &one_way))
11986            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
11987            .headers(header_map)
11988            .build()?;
11989        let info = OperationInfo {
11990            operation_id: "operations_check",
11991        };
11992        self.pre(&mut request, &info).await?;
11993        let result = self.exec(request, &info).await;
11994        self.post(&result, &info).await?;
11995        let response = result?;
11996        match response.status().as_u16() {
11997            200u16 => ResponseValue::from_response(response).await,
11998            400u16..=499u16 => Err(Error::ErrorResponse(
11999                ResponseValue::from_response(response).await?,
12000            )),
12001            500u16..=599u16 => Err(Error::ErrorResponse(
12002                ResponseValue::from_response(response).await?,
12003            )),
12004            _ => Err(Error::UnexpectedResponse(response)),
12005        }
12006    }
12007
12008    ///Sync source to destination
12009    ///
12010    ///Synchronises a source remote to a destination remote, making the
12011    /// destination match the source.
12012    ///
12013    ///Sends a `POST` request to `/sync/sync`
12014    ///
12015    ///Arguments:
12016    /// - `async_`: Run the command asynchronously. Returns a job id
12017    ///   immediately.
12018    /// - `config`: JSON encoded config overrides applied for this call only.
12019    /// - `filter`: JSON encoded filter overrides applied for this call only.
12020    /// - `group`: Assign the request to a custom stats group.
12021    /// - `create_empty_src_dirs`: Set to true to create empty source
12022    ///   directories on the destination.
12023    /// - `dst_fs`: Destination remote path to sync to, e.g. `drive:dst`.
12024    /// - `src_fs`: Source remote path to sync from, e.g. `drive:src`.
12025    pub async fn sync_sync<'a>(
12026        &'a self,
12027        async_: Option<bool>,
12028        config: Option<&'a str>,
12029        filter: Option<&'a str>,
12030        group: Option<&'a str>,
12031        create_empty_src_dirs: Option<bool>,
12032        dst_fs: &'a str,
12033        src_fs: &'a str,
12034    ) -> Result<ResponseValue<types::SyncSyncResponse>, Error<types::RcError>> {
12035        let url = format!("{}/sync/sync", self.baseurl,);
12036        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12037        header_map.append(
12038            ::reqwest::header::HeaderName::from_static("api-version"),
12039            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12040        );
12041        #[allow(unused_mut)]
12042        let mut request = self
12043            .client
12044            .post(url)
12045            .header(
12046                ::reqwest::header::ACCEPT,
12047                ::reqwest::header::HeaderValue::from_static("application/json"),
12048            )
12049            .query(&progenitor_client::QueryParam::new("_async", &async_))
12050            .query(&progenitor_client::QueryParam::new("_config", &config))
12051            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12052            .query(&progenitor_client::QueryParam::new("_group", &group))
12053            .query(&progenitor_client::QueryParam::new(
12054                "createEmptySrcDirs",
12055                &create_empty_src_dirs,
12056            ))
12057            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12058            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12059            .headers(header_map)
12060            .build()?;
12061        let info = OperationInfo {
12062            operation_id: "sync_sync",
12063        };
12064        self.pre(&mut request, &info).await?;
12065        let result = self.exec(request, &info).await;
12066        self.post(&result, &info).await?;
12067        let response = result?;
12068        match response.status().as_u16() {
12069            200u16 => ResponseValue::from_response(response).await,
12070            400u16..=499u16 => Err(Error::ErrorResponse(
12071                ResponseValue::from_response(response).await?,
12072            )),
12073            500u16..=599u16 => Err(Error::ErrorResponse(
12074                ResponseValue::from_response(response).await?,
12075            )),
12076            _ => Err(Error::UnexpectedResponse(response)),
12077        }
12078    }
12079
12080    ///Copy source to destination
12081    ///
12082    ///Copies objects from a source remote to a destination remote without
12083    /// deleting destination files.
12084    ///
12085    ///Sends a `POST` request to `/sync/copy`
12086    ///
12087    ///Arguments:
12088    /// - `async_`: Run the command asynchronously. Returns a job id
12089    ///   immediately.
12090    /// - `config`: JSON encoded config overrides applied for this call only.
12091    /// - `filter`: JSON encoded filter overrides applied for this call only.
12092    /// - `group`: Assign the request to a custom stats group.
12093    /// - `create_empty_src_dirs`: Set to true to replicate empty source
12094    ///   directories on the destination.
12095    /// - `dst_fs`: Destination remote path to copy to.
12096    /// - `src_fs`: Source remote path to copy from.
12097    pub async fn sync_copy<'a>(
12098        &'a self,
12099        async_: Option<bool>,
12100        config: Option<&'a str>,
12101        filter: Option<&'a str>,
12102        group: Option<&'a str>,
12103        create_empty_src_dirs: Option<bool>,
12104        dst_fs: &'a str,
12105        src_fs: &'a str,
12106    ) -> Result<ResponseValue<types::SyncCopyResponse>, Error<types::RcError>> {
12107        let url = format!("{}/sync/copy", self.baseurl,);
12108        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12109        header_map.append(
12110            ::reqwest::header::HeaderName::from_static("api-version"),
12111            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12112        );
12113        #[allow(unused_mut)]
12114        let mut request = self
12115            .client
12116            .post(url)
12117            .header(
12118                ::reqwest::header::ACCEPT,
12119                ::reqwest::header::HeaderValue::from_static("application/json"),
12120            )
12121            .query(&progenitor_client::QueryParam::new("_async", &async_))
12122            .query(&progenitor_client::QueryParam::new("_config", &config))
12123            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12124            .query(&progenitor_client::QueryParam::new("_group", &group))
12125            .query(&progenitor_client::QueryParam::new(
12126                "createEmptySrcDirs",
12127                &create_empty_src_dirs,
12128            ))
12129            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12130            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12131            .headers(header_map)
12132            .build()?;
12133        let info = OperationInfo {
12134            operation_id: "sync_copy",
12135        };
12136        self.pre(&mut request, &info).await?;
12137        let result = self.exec(request, &info).await;
12138        self.post(&result, &info).await?;
12139        let response = result?;
12140        match response.status().as_u16() {
12141            200u16 => ResponseValue::from_response(response).await,
12142            400u16..=499u16 => Err(Error::ErrorResponse(
12143                ResponseValue::from_response(response).await?,
12144            )),
12145            500u16..=599u16 => Err(Error::ErrorResponse(
12146                ResponseValue::from_response(response).await?,
12147            )),
12148            _ => Err(Error::UnexpectedResponse(response)),
12149        }
12150    }
12151
12152    ///Move source to destination
12153    ///
12154    ///Moves objects from a source remote to a destination remote, optionally
12155    /// cleaning up empty directories.
12156    ///
12157    ///Sends a `POST` request to `/sync/move`
12158    ///
12159    ///Arguments:
12160    /// - `async_`: Run the command asynchronously. Returns a job id
12161    ///   immediately.
12162    /// - `config`: JSON encoded config overrides applied for this call only.
12163    /// - `filter`: JSON encoded filter overrides applied for this call only.
12164    /// - `group`: Assign the request to a custom stats group.
12165    /// - `create_empty_src_dirs`: Set to true to create empty source
12166    ///   directories on the destination.
12167    /// - `delete_empty_src_dirs`: Set to true to delete empty directories from
12168    ///   the source after the move completes.
12169    /// - `dst_fs`: Destination remote path that will receive moved files.
12170    /// - `src_fs`: Source remote path whose contents will be moved.
12171    pub async fn sync_move<'a>(
12172        &'a self,
12173        async_: Option<bool>,
12174        config: Option<&'a str>,
12175        filter: Option<&'a str>,
12176        group: Option<&'a str>,
12177        create_empty_src_dirs: Option<bool>,
12178        delete_empty_src_dirs: Option<bool>,
12179        dst_fs: &'a str,
12180        src_fs: &'a str,
12181    ) -> Result<ResponseValue<types::SyncMoveResponse>, Error<types::RcError>> {
12182        let url = format!("{}/sync/move", self.baseurl,);
12183        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12184        header_map.append(
12185            ::reqwest::header::HeaderName::from_static("api-version"),
12186            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12187        );
12188        #[allow(unused_mut)]
12189        let mut request = self
12190            .client
12191            .post(url)
12192            .header(
12193                ::reqwest::header::ACCEPT,
12194                ::reqwest::header::HeaderValue::from_static("application/json"),
12195            )
12196            .query(&progenitor_client::QueryParam::new("_async", &async_))
12197            .query(&progenitor_client::QueryParam::new("_config", &config))
12198            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12199            .query(&progenitor_client::QueryParam::new("_group", &group))
12200            .query(&progenitor_client::QueryParam::new(
12201                "createEmptySrcDirs",
12202                &create_empty_src_dirs,
12203            ))
12204            .query(&progenitor_client::QueryParam::new(
12205                "deleteEmptySrcDirs",
12206                &delete_empty_src_dirs,
12207            ))
12208            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12209            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12210            .headers(header_map)
12211            .build()?;
12212        let info = OperationInfo {
12213            operation_id: "sync_move",
12214        };
12215        self.pre(&mut request, &info).await?;
12216        let result = self.exec(request, &info).await;
12217        self.post(&result, &info).await?;
12218        let response = result?;
12219        match response.status().as_u16() {
12220            200u16 => ResponseValue::from_response(response).await,
12221            400u16..=499u16 => Err(Error::ErrorResponse(
12222                ResponseValue::from_response(response).await?,
12223            )),
12224            500u16..=599u16 => Err(Error::ErrorResponse(
12225                ResponseValue::from_response(response).await?,
12226            )),
12227            _ => Err(Error::UnexpectedResponse(response)),
12228        }
12229    }
12230
12231    ///Bidirectional sync
12232    ///
12233    ///Performs a bidirectional synchronisation between two paths, supporting
12234    /// safety checks and recovery options.
12235    ///
12236    ///Sends a `POST` request to `/sync/bisync`
12237    ///
12238    ///Arguments:
12239    /// - `async_`: Run the command asynchronously. Returns a job id
12240    ///   immediately.
12241    /// - `config`: JSON encoded config overrides applied for this call only.
12242    /// - `filter`: JSON encoded filter overrides applied for this call only.
12243    /// - `group`: Assign the request to a custom stats group.
12244    /// - `backupdir1`: Backup directory on the first remote for changed files.
12245    /// - `backupdir2`: Backup directory on the second remote for changed files.
12246    /// - `check_access`: Set to true to abort if `RCLONE_TEST` files are
12247    ///   missing on either side.
12248    /// - `check_filename`: Override the access-check sentinel filename;
12249    ///   defaults to `RCLONE_TEST`.
12250    /// - `check_sync`: Controls final listing comparison; leave true for normal
12251    ///   verification or set false to skip.
12252    /// - `create_empty_src_dirs`: Set to true to mirror empty directories
12253    ///   between the two paths.
12254    /// - `dry_run`: Set to true to simulate the bisync run without making
12255    ///   changes.
12256    /// - `filters_file`: Path to an rclone filters file applied to both paths.
12257    /// - `force`: Set to true to bypass the `maxDelete` safety check.
12258    /// - `ignore_listing_checksum`: Set to true to ignore checksum differences
12259    ///   when comparing listings.
12260    /// - `max_delete`: Abort the run if deletions exceed this percentage
12261    ///   (default 50).
12262    /// - `no_cleanup`: Set to true to keep bisync working files after
12263    ///   completion.
12264    /// - `path1`: First remote directory, e.g. `drive:path1`.
12265    /// - `path2`: Second remote directory, e.g. `drive:path2`.
12266    /// - `remove_empty_dirs`: Set to true to remove empty directories during
12267    ///   cleanup.
12268    /// - `resilient`: Set to true to allow retrying after certain recoverable
12269    ///   errors.
12270    /// - `resync`: Set to true to perform a one-time resync, rebuilding bisync
12271    ///   history.
12272    /// - `workdir`: Directory path used to store bisync working files.
12273    pub async fn sync_bisync<'a>(
12274        &'a self,
12275        async_: Option<bool>,
12276        config: Option<&'a str>,
12277        filter: Option<&'a str>,
12278        group: Option<&'a str>,
12279        backupdir1: Option<&'a str>,
12280        backupdir2: Option<&'a str>,
12281        check_access: Option<bool>,
12282        check_filename: Option<&'a str>,
12283        check_sync: Option<bool>,
12284        create_empty_src_dirs: Option<bool>,
12285        dry_run: Option<bool>,
12286        filters_file: Option<&'a str>,
12287        force: Option<bool>,
12288        ignore_listing_checksum: Option<bool>,
12289        max_delete: Option<f64>,
12290        no_cleanup: Option<bool>,
12291        path1: &'a str,
12292        path2: &'a str,
12293        remove_empty_dirs: Option<bool>,
12294        resilient: Option<bool>,
12295        resync: Option<bool>,
12296        workdir: Option<&'a str>,
12297    ) -> Result<ResponseValue<types::SyncBisyncResponse>, Error<types::RcError>> {
12298        let url = format!("{}/sync/bisync", self.baseurl,);
12299        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12300        header_map.append(
12301            ::reqwest::header::HeaderName::from_static("api-version"),
12302            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12303        );
12304        #[allow(unused_mut)]
12305        let mut request = self
12306            .client
12307            .post(url)
12308            .header(
12309                ::reqwest::header::ACCEPT,
12310                ::reqwest::header::HeaderValue::from_static("application/json"),
12311            )
12312            .query(&progenitor_client::QueryParam::new("_async", &async_))
12313            .query(&progenitor_client::QueryParam::new("_config", &config))
12314            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12315            .query(&progenitor_client::QueryParam::new("_group", &group))
12316            .query(&progenitor_client::QueryParam::new(
12317                "backupdir1",
12318                &backupdir1,
12319            ))
12320            .query(&progenitor_client::QueryParam::new(
12321                "backupdir2",
12322                &backupdir2,
12323            ))
12324            .query(&progenitor_client::QueryParam::new(
12325                "checkAccess",
12326                &check_access,
12327            ))
12328            .query(&progenitor_client::QueryParam::new(
12329                "checkFilename",
12330                &check_filename,
12331            ))
12332            .query(&progenitor_client::QueryParam::new(
12333                "checkSync",
12334                &check_sync,
12335            ))
12336            .query(&progenitor_client::QueryParam::new(
12337                "createEmptySrcDirs",
12338                &create_empty_src_dirs,
12339            ))
12340            .query(&progenitor_client::QueryParam::new("dryRun", &dry_run))
12341            .query(&progenitor_client::QueryParam::new(
12342                "filtersFile",
12343                &filters_file,
12344            ))
12345            .query(&progenitor_client::QueryParam::new("force", &force))
12346            .query(&progenitor_client::QueryParam::new(
12347                "ignoreListingChecksum",
12348                &ignore_listing_checksum,
12349            ))
12350            .query(&progenitor_client::QueryParam::new(
12351                "maxDelete",
12352                &max_delete,
12353            ))
12354            .query(&progenitor_client::QueryParam::new(
12355                "noCleanup",
12356                &no_cleanup,
12357            ))
12358            .query(&progenitor_client::QueryParam::new("path1", &path1))
12359            .query(&progenitor_client::QueryParam::new("path2", &path2))
12360            .query(&progenitor_client::QueryParam::new(
12361                "removeEmptyDirs",
12362                &remove_empty_dirs,
12363            ))
12364            .query(&progenitor_client::QueryParam::new("resilient", &resilient))
12365            .query(&progenitor_client::QueryParam::new("resync", &resync))
12366            .query(&progenitor_client::QueryParam::new("workdir", &workdir))
12367            .headers(header_map)
12368            .build()?;
12369        let info = OperationInfo {
12370            operation_id: "sync_bisync",
12371        };
12372        self.pre(&mut request, &info).await?;
12373        let result = self.exec(request, &info).await;
12374        self.post(&result, &info).await?;
12375        let response = result?;
12376        match response.status().as_u16() {
12377            200u16 => ResponseValue::from_response(response).await,
12378            400u16..=499u16 => Err(Error::ErrorResponse(
12379                ResponseValue::from_response(response).await?,
12380            )),
12381            500u16..=599u16 => Err(Error::ErrorResponse(
12382                ResponseValue::from_response(response).await?,
12383            )),
12384            _ => Err(Error::UnexpectedResponse(response)),
12385        }
12386    }
12387
12388    ///List option blocks
12389    ///
12390    ///Returns the names of option blocks that can be queried or updated.
12391    ///
12392    ///Sends a `POST` request to `/options/blocks`
12393    ///
12394    ///Arguments:
12395    /// - `async_`: Run the command asynchronously. Returns a job id
12396    ///   immediately.
12397    /// - `group`: Assign the request to a custom stats group.
12398    pub async fn options_blocks<'a>(
12399        &'a self,
12400        async_: Option<bool>,
12401        group: Option<&'a str>,
12402    ) -> Result<ResponseValue<types::OptionsBlocksResponse>, Error<types::RcError>> {
12403        let url = format!("{}/options/blocks", self.baseurl,);
12404        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12405        header_map.append(
12406            ::reqwest::header::HeaderName::from_static("api-version"),
12407            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12408        );
12409        #[allow(unused_mut)]
12410        let mut request = self
12411            .client
12412            .post(url)
12413            .header(
12414                ::reqwest::header::ACCEPT,
12415                ::reqwest::header::HeaderValue::from_static("application/json"),
12416            )
12417            .query(&progenitor_client::QueryParam::new("_async", &async_))
12418            .query(&progenitor_client::QueryParam::new("_group", &group))
12419            .headers(header_map)
12420            .build()?;
12421        let info = OperationInfo {
12422            operation_id: "options_blocks",
12423        };
12424        self.pre(&mut request, &info).await?;
12425        let result = self.exec(request, &info).await;
12426        self.post(&result, &info).await?;
12427        let response = result?;
12428        match response.status().as_u16() {
12429            200u16 => ResponseValue::from_response(response).await,
12430            400u16..=499u16 => Err(Error::ErrorResponse(
12431                ResponseValue::from_response(response).await?,
12432            )),
12433            500u16..=599u16 => Err(Error::ErrorResponse(
12434                ResponseValue::from_response(response).await?,
12435            )),
12436            _ => Err(Error::UnexpectedResponse(response)),
12437        }
12438    }
12439
12440    ///Get option values
12441    ///
12442    ///Returns the current global option values, optionally filtered by block.
12443    ///
12444    ///Sends a `POST` request to `/options/get`
12445    ///
12446    ///Arguments:
12447    /// - `async_`: Run the command asynchronously. Returns a job id
12448    ///   immediately.
12449    /// - `group`: Assign the request to a custom stats group.
12450    /// - `blocks`: Optional comma-separated list of option block names to
12451    ///   return.
12452    pub async fn options_get<'a>(
12453        &'a self,
12454        async_: Option<bool>,
12455        group: Option<&'a str>,
12456        blocks: Option<&'a str>,
12457    ) -> Result<ResponseValue<types::OptionsGetResponse>, Error<types::RcError>> {
12458        let url = format!("{}/options/get", self.baseurl,);
12459        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12460        header_map.append(
12461            ::reqwest::header::HeaderName::from_static("api-version"),
12462            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12463        );
12464        #[allow(unused_mut)]
12465        let mut request = self
12466            .client
12467            .post(url)
12468            .header(
12469                ::reqwest::header::ACCEPT,
12470                ::reqwest::header::HeaderValue::from_static("application/json"),
12471            )
12472            .query(&progenitor_client::QueryParam::new("_async", &async_))
12473            .query(&progenitor_client::QueryParam::new("_group", &group))
12474            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12475            .headers(header_map)
12476            .build()?;
12477        let info = OperationInfo {
12478            operation_id: "options_get",
12479        };
12480        self.pre(&mut request, &info).await?;
12481        let result = self.exec(request, &info).await;
12482        self.post(&result, &info).await?;
12483        let response = result?;
12484        match response.status().as_u16() {
12485            200u16 => ResponseValue::from_response(response).await,
12486            400u16..=499u16 => Err(Error::ErrorResponse(
12487                ResponseValue::from_response(response).await?,
12488            )),
12489            500u16..=599u16 => Err(Error::ErrorResponse(
12490                ResponseValue::from_response(response).await?,
12491            )),
12492            _ => Err(Error::UnexpectedResponse(response)),
12493        }
12494    }
12495
12496    ///Describe options
12497    ///
12498    ///Returns metadata for options, including help text and defaults, grouped
12499    /// by block.
12500    ///
12501    ///Sends a `POST` request to `/options/info`
12502    ///
12503    ///Arguments:
12504    /// - `async_`: Run the command asynchronously. Returns a job id
12505    ///   immediately.
12506    /// - `group`: Assign the request to a custom stats group.
12507    /// - `blocks`: Optional comma-separated list of option block names to
12508    ///   describe.
12509    pub async fn options_info<'a>(
12510        &'a self,
12511        async_: Option<bool>,
12512        group: Option<&'a str>,
12513        blocks: Option<&'a str>,
12514    ) -> Result<ResponseValue<types::OptionsInfoResponse>, Error<types::RcError>> {
12515        let url = format!("{}/options/info", self.baseurl,);
12516        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12517        header_map.append(
12518            ::reqwest::header::HeaderName::from_static("api-version"),
12519            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12520        );
12521        #[allow(unused_mut)]
12522        let mut request = self
12523            .client
12524            .post(url)
12525            .header(
12526                ::reqwest::header::ACCEPT,
12527                ::reqwest::header::HeaderValue::from_static("application/json"),
12528            )
12529            .query(&progenitor_client::QueryParam::new("_async", &async_))
12530            .query(&progenitor_client::QueryParam::new("_group", &group))
12531            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12532            .headers(header_map)
12533            .build()?;
12534        let info = OperationInfo {
12535            operation_id: "options_info",
12536        };
12537        self.pre(&mut request, &info).await?;
12538        let result = self.exec(request, &info).await;
12539        self.post(&result, &info).await?;
12540        let response = result?;
12541        match response.status().as_u16() {
12542            200u16 => ResponseValue::from_response(response).await,
12543            400u16..=499u16 => Err(Error::ErrorResponse(
12544                ResponseValue::from_response(response).await?,
12545            )),
12546            500u16..=599u16 => Err(Error::ErrorResponse(
12547                ResponseValue::from_response(response).await?,
12548            )),
12549            _ => Err(Error::UnexpectedResponse(response)),
12550        }
12551    }
12552
12553    ///Set option values
12554    ///
12555    ///Sets temporary option overrides for the running process by supplying
12556    /// key/value pairs grouped under option block names. Provide one or more
12557    /// query parameters whose names match the blocks you want to modify (for
12558    /// example `main`, `rc`, `http`). Each block parameter carries an object of
12559    /// option overrides.
12560    ///
12561    ///
12562    ///Sends a `POST` request to `/options/set`
12563    ///
12564    ///Arguments:
12565    /// - `async_`: Run the command asynchronously. Returns a job id
12566    ///   immediately.
12567    /// - `group`: Assign the request to a custom stats group.
12568    /// - `dlna`: Overrides for the `dlna` option block.
12569    /// - `filter`: Overrides for the `filter` option block.
12570    /// - `ftp`: Overrides for the `ftp` option block.
12571    /// - `http`: Overrides for the `http` option block.
12572    /// - `log`: Overrides for the `log` option block.
12573    /// - `main`: Overrides for the `main` option block.
12574    /// - `mount`: Overrides for the `mount` option block.
12575    /// - `nfs`: Overrides for the `nfs` option block.
12576    /// - `proxy`: Overrides for the `proxy` option block.
12577    /// - `rc`: Overrides for the `rc` option block.
12578    /// - `restic`: Overrides for the `restic` option block.
12579    /// - `s3`: Overrides for the `s3` option block.
12580    /// - `sftp`: Overrides for the `sftp` option block.
12581    /// - `vfs`: Overrides for the `vfs` option block.
12582    /// - `webdav`: Overrides for the `webdav` option block.
12583    pub async fn options_set<'a>(
12584        &'a self,
12585        async_: Option<bool>,
12586        group: Option<&'a str>,
12587        dlna: Option<
12588            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetDlnaValue>,
12589        >,
12590        filter: Option<
12591            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFilterValue>,
12592        >,
12593        ftp: Option<
12594            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFtpValue>,
12595        >,
12596        http: Option<
12597            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetHttpValue>,
12598        >,
12599        log: Option<
12600            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetLogValue>,
12601        >,
12602        main: Option<
12603            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMainValue>,
12604        >,
12605        mount: Option<
12606            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMountValue>,
12607        >,
12608        nfs: Option<
12609            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetNfsValue>,
12610        >,
12611        proxy: Option<
12612            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetProxyValue>,
12613        >,
12614        rc: Option<
12615            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetRcValue>,
12616        >,
12617        restic: Option<
12618            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetResticValue>,
12619        >,
12620        s3: Option<
12621            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetS3Value>,
12622        >,
12623        sftp: Option<
12624            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetSftpValue>,
12625        >,
12626        vfs: Option<
12627            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetVfsValue>,
12628        >,
12629        webdav: Option<
12630            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetWebdavValue>,
12631        >,
12632    ) -> Result<
12633        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12634        Error<types::RcError>,
12635    > {
12636        let url = format!("{}/options/set", self.baseurl,);
12637        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12638        header_map.append(
12639            ::reqwest::header::HeaderName::from_static("api-version"),
12640            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12641        );
12642        #[allow(unused_mut)]
12643        let mut request = self
12644            .client
12645            .post(url)
12646            .header(
12647                ::reqwest::header::ACCEPT,
12648                ::reqwest::header::HeaderValue::from_static("application/json"),
12649            )
12650            .query(&progenitor_client::QueryParam::new("_async", &async_))
12651            .query(&progenitor_client::QueryParam::new("_group", &group))
12652            .query(&progenitor_client::QueryParam::new("dlna", &dlna))
12653            .query(&progenitor_client::QueryParam::new("filter", &filter))
12654            .query(&progenitor_client::QueryParam::new("ftp", &ftp))
12655            .query(&progenitor_client::QueryParam::new("http", &http))
12656            .query(&progenitor_client::QueryParam::new("log", &log))
12657            .query(&progenitor_client::QueryParam::new("main", &main))
12658            .query(&progenitor_client::QueryParam::new("mount", &mount))
12659            .query(&progenitor_client::QueryParam::new("nfs", &nfs))
12660            .query(&progenitor_client::QueryParam::new("proxy", &proxy))
12661            .query(&progenitor_client::QueryParam::new("rc", &rc))
12662            .query(&progenitor_client::QueryParam::new("restic", &restic))
12663            .query(&progenitor_client::QueryParam::new("s3", &s3))
12664            .query(&progenitor_client::QueryParam::new("sftp", &sftp))
12665            .query(&progenitor_client::QueryParam::new("vfs", &vfs))
12666            .query(&progenitor_client::QueryParam::new("webdav", &webdav))
12667            .headers(header_map)
12668            .build()?;
12669        let info = OperationInfo {
12670            operation_id: "options_set",
12671        };
12672        self.pre(&mut request, &info).await?;
12673        let result = self.exec(request, &info).await;
12674        self.post(&result, &info).await?;
12675        let response = result?;
12676        match response.status().as_u16() {
12677            200u16 => ResponseValue::from_response(response).await,
12678            400u16..=499u16 => Err(Error::ErrorResponse(
12679                ResponseValue::from_response(response).await?,
12680            )),
12681            500u16..=599u16 => Err(Error::ErrorResponse(
12682                ResponseValue::from_response(response).await?,
12683            )),
12684            _ => Err(Error::UnexpectedResponse(response)),
12685        }
12686    }
12687
12688    ///Show effective options
12689    ///
12690    ///Returns the current effective options for this request, including
12691    /// `_config` and `_filter` overrides.
12692    ///
12693    ///Sends a `POST` request to `/options/local`
12694    ///
12695    ///Arguments:
12696    /// - `async_`: Run the command asynchronously. Returns a job id
12697    ///   immediately.
12698    /// - `group`: Assign the request to a custom stats group.
12699    pub async fn options_local<'a>(
12700        &'a self,
12701        async_: Option<bool>,
12702        group: Option<&'a str>,
12703    ) -> Result<ResponseValue<types::OptionsLocalResponse>, Error<types::RcError>> {
12704        let url = format!("{}/options/local", self.baseurl,);
12705        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12706        header_map.append(
12707            ::reqwest::header::HeaderName::from_static("api-version"),
12708            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12709        );
12710        #[allow(unused_mut)]
12711        let mut request = self
12712            .client
12713            .post(url)
12714            .header(
12715                ::reqwest::header::ACCEPT,
12716                ::reqwest::header::HeaderValue::from_static("application/json"),
12717            )
12718            .query(&progenitor_client::QueryParam::new("_async", &async_))
12719            .query(&progenitor_client::QueryParam::new("_group", &group))
12720            .headers(header_map)
12721            .build()?;
12722        let info = OperationInfo {
12723            operation_id: "options_local",
12724        };
12725        self.pre(&mut request, &info).await?;
12726        let result = self.exec(request, &info).await;
12727        self.post(&result, &info).await?;
12728        let response = result?;
12729        match response.status().as_u16() {
12730            200u16 => ResponseValue::from_response(response).await,
12731            400u16..=499u16 => Err(Error::ErrorResponse(
12732                ResponseValue::from_response(response).await?,
12733            )),
12734            500u16..=599u16 => Err(Error::ErrorResponse(
12735                ResponseValue::from_response(response).await?,
12736            )),
12737            _ => Err(Error::UnexpectedResponse(response)),
12738        }
12739    }
12740
12741    ///List serve instances
12742    ///
12743    ///Returns all running `rclone serve` instances with their IDs and options.
12744    ///
12745    ///Sends a `POST` request to `/serve/list`
12746    ///
12747    ///Arguments:
12748    /// - `async_`: Run the command asynchronously. Returns a job id
12749    ///   immediately.
12750    /// - `group`: Assign the request to a custom stats group.
12751    pub async fn serve_list<'a>(
12752        &'a self,
12753        async_: Option<bool>,
12754        group: Option<&'a str>,
12755    ) -> Result<ResponseValue<types::ServeListResponse>, Error<types::RcError>> {
12756        let url = format!("{}/serve/list", self.baseurl,);
12757        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12758        header_map.append(
12759            ::reqwest::header::HeaderName::from_static("api-version"),
12760            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12761        );
12762        #[allow(unused_mut)]
12763        let mut request = self
12764            .client
12765            .post(url)
12766            .header(
12767                ::reqwest::header::ACCEPT,
12768                ::reqwest::header::HeaderValue::from_static("application/json"),
12769            )
12770            .query(&progenitor_client::QueryParam::new("_async", &async_))
12771            .query(&progenitor_client::QueryParam::new("_group", &group))
12772            .headers(header_map)
12773            .build()?;
12774        let info = OperationInfo {
12775            operation_id: "serve_list",
12776        };
12777        self.pre(&mut request, &info).await?;
12778        let result = self.exec(request, &info).await;
12779        self.post(&result, &info).await?;
12780        let response = result?;
12781        match response.status().as_u16() {
12782            200u16 => ResponseValue::from_response(response).await,
12783            400u16..=499u16 => Err(Error::ErrorResponse(
12784                ResponseValue::from_response(response).await?,
12785            )),
12786            500u16..=599u16 => Err(Error::ErrorResponse(
12787                ResponseValue::from_response(response).await?,
12788            )),
12789            _ => Err(Error::UnexpectedResponse(response)),
12790        }
12791    }
12792
12793    ///Start serve instance
12794    ///
12795    ///Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with
12796    /// the provided parameters.
12797    ///
12798    ///Sends a `POST` request to `/serve/start`
12799    ///
12800    ///Arguments:
12801    /// - `async_`: Run the command asynchronously. Returns a job id
12802    ///   immediately.
12803    /// - `config`: JSON encoded config overrides applied for this call only.
12804    /// - `filter`: JSON encoded filter overrides applied for this call only.
12805    /// - `group`: Assign the request to a custom stats group.
12806    /// - `addr`: Address and port to bind the server to, such as `:5572` or
12807    ///   `localhost:8080`.
12808    /// - `fs`: Remote path that will be served.
12809    /// - `params`: Additional arbitrary parameters allowed.
12810    /// - `type_`: Type of server to start (e.g. `http`, `webdav`, `ftp`,
12811    ///   `sftp`).
12812    pub async fn serve_start<'a>(
12813        &'a self,
12814        async_: Option<bool>,
12815        config: Option<&'a str>,
12816        filter: Option<&'a str>,
12817        group: Option<&'a str>,
12818        addr: &'a str,
12819        fs: &'a str,
12820        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12821        type_: &'a str,
12822    ) -> Result<ResponseValue<types::ServeStartResponse>, Error<types::RcError>> {
12823        let url = format!("{}/serve/start", self.baseurl,);
12824        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12825        header_map.append(
12826            ::reqwest::header::HeaderName::from_static("api-version"),
12827            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12828        );
12829        #[allow(unused_mut)]
12830        let mut request = self
12831            .client
12832            .post(url)
12833            .header(
12834                ::reqwest::header::ACCEPT,
12835                ::reqwest::header::HeaderValue::from_static("application/json"),
12836            )
12837            .query(&progenitor_client::QueryParam::new("_async", &async_))
12838            .query(&progenitor_client::QueryParam::new("_config", &config))
12839            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12840            .query(&progenitor_client::QueryParam::new("_group", &group))
12841            .query(&progenitor_client::QueryParam::new("addr", &addr))
12842            .query(&progenitor_client::QueryParam::new("fs", &fs))
12843            .query(&progenitor_client::QueryParam::new("params", &params))
12844            .query(&progenitor_client::QueryParam::new("type", &type_))
12845            .headers(header_map)
12846            .build()?;
12847        let info = OperationInfo {
12848            operation_id: "serve_start",
12849        };
12850        self.pre(&mut request, &info).await?;
12851        let result = self.exec(request, &info).await;
12852        self.post(&result, &info).await?;
12853        let response = result?;
12854        match response.status().as_u16() {
12855            200u16 => ResponseValue::from_response(response).await,
12856            400u16..=499u16 => Err(Error::ErrorResponse(
12857                ResponseValue::from_response(response).await?,
12858            )),
12859            500u16..=599u16 => Err(Error::ErrorResponse(
12860                ResponseValue::from_response(response).await?,
12861            )),
12862            _ => Err(Error::UnexpectedResponse(response)),
12863        }
12864    }
12865
12866    ///Stop serve instance
12867    ///
12868    ///Stops a running `serve` instance identified by its ID.
12869    ///
12870    ///Sends a `POST` request to `/serve/stop`
12871    ///
12872    ///Arguments:
12873    /// - `async_`: Run the command asynchronously. Returns a job id
12874    ///   immediately.
12875    /// - `group`: Assign the request to a custom stats group.
12876    /// - `id`: Identifier of the running serve instance returned by
12877    ///   `serve/start`.
12878    pub async fn serve_stop<'a>(
12879        &'a self,
12880        async_: Option<bool>,
12881        group: Option<&'a str>,
12882        id: &'a str,
12883    ) -> Result<
12884        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12885        Error<types::RcError>,
12886    > {
12887        let url = format!("{}/serve/stop", self.baseurl,);
12888        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12889        header_map.append(
12890            ::reqwest::header::HeaderName::from_static("api-version"),
12891            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12892        );
12893        #[allow(unused_mut)]
12894        let mut request = self
12895            .client
12896            .post(url)
12897            .header(
12898                ::reqwest::header::ACCEPT,
12899                ::reqwest::header::HeaderValue::from_static("application/json"),
12900            )
12901            .query(&progenitor_client::QueryParam::new("_async", &async_))
12902            .query(&progenitor_client::QueryParam::new("_group", &group))
12903            .query(&progenitor_client::QueryParam::new("id", &id))
12904            .headers(header_map)
12905            .build()?;
12906        let info = OperationInfo {
12907            operation_id: "serve_stop",
12908        };
12909        self.pre(&mut request, &info).await?;
12910        let result = self.exec(request, &info).await;
12911        self.post(&result, &info).await?;
12912        let response = result?;
12913        match response.status().as_u16() {
12914            200u16 => ResponseValue::from_response(response).await,
12915            400u16..=499u16 => Err(Error::ErrorResponse(
12916                ResponseValue::from_response(response).await?,
12917            )),
12918            500u16..=599u16 => Err(Error::ErrorResponse(
12919                ResponseValue::from_response(response).await?,
12920            )),
12921            _ => Err(Error::UnexpectedResponse(response)),
12922        }
12923    }
12924
12925    ///Stop all serve instances
12926    ///
12927    ///Stops every active `serve` instance.
12928    ///
12929    ///Sends a `POST` request to `/serve/stopall`
12930    ///
12931    ///Arguments:
12932    /// - `async_`: Run the command asynchronously. Returns a job id
12933    ///   immediately.
12934    /// - `group`: Assign the request to a custom stats group.
12935    pub async fn serve_stopall<'a>(
12936        &'a self,
12937        async_: Option<bool>,
12938        group: Option<&'a str>,
12939    ) -> Result<
12940        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12941        Error<types::RcError>,
12942    > {
12943        let url = format!("{}/serve/stopall", self.baseurl,);
12944        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12945        header_map.append(
12946            ::reqwest::header::HeaderName::from_static("api-version"),
12947            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12948        );
12949        #[allow(unused_mut)]
12950        let mut request = self
12951            .client
12952            .post(url)
12953            .header(
12954                ::reqwest::header::ACCEPT,
12955                ::reqwest::header::HeaderValue::from_static("application/json"),
12956            )
12957            .query(&progenitor_client::QueryParam::new("_async", &async_))
12958            .query(&progenitor_client::QueryParam::new("_group", &group))
12959            .headers(header_map)
12960            .build()?;
12961        let info = OperationInfo {
12962            operation_id: "serve_stopall",
12963        };
12964        self.pre(&mut request, &info).await?;
12965        let result = self.exec(request, &info).await;
12966        self.post(&result, &info).await?;
12967        let response = result?;
12968        match response.status().as_u16() {
12969            200u16 => ResponseValue::from_response(response).await,
12970            400u16..=499u16 => Err(Error::ErrorResponse(
12971                ResponseValue::from_response(response).await?,
12972            )),
12973            500u16..=599u16 => Err(Error::ErrorResponse(
12974                ResponseValue::from_response(response).await?,
12975            )),
12976            _ => Err(Error::UnexpectedResponse(response)),
12977        }
12978    }
12979
12980    ///List serve types
12981    ///
12982    ///Returns the list of supported `rclone serve` protocols.
12983    ///
12984    ///Sends a `POST` request to `/serve/types`
12985    ///
12986    ///Arguments:
12987    /// - `async_`: Run the command asynchronously. Returns a job id
12988    ///   immediately.
12989    /// - `group`: Assign the request to a custom stats group.
12990    pub async fn serve_types<'a>(
12991        &'a self,
12992        async_: Option<bool>,
12993        group: Option<&'a str>,
12994    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
12995        let url = format!("{}/serve/types", self.baseurl,);
12996        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12997        header_map.append(
12998            ::reqwest::header::HeaderName::from_static("api-version"),
12999            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13000        );
13001        #[allow(unused_mut)]
13002        let mut request = self
13003            .client
13004            .post(url)
13005            .header(
13006                ::reqwest::header::ACCEPT,
13007                ::reqwest::header::HeaderValue::from_static("application/json"),
13008            )
13009            .query(&progenitor_client::QueryParam::new("_async", &async_))
13010            .query(&progenitor_client::QueryParam::new("_group", &group))
13011            .headers(header_map)
13012            .build()?;
13013        let info = OperationInfo {
13014            operation_id: "serve_types",
13015        };
13016        self.pre(&mut request, &info).await?;
13017        let result = self.exec(request, &info).await;
13018        self.post(&result, &info).await?;
13019        let response = result?;
13020        match response.status().as_u16() {
13021            200u16 => Ok(ResponseValue::empty(response)),
13022            400u16..=499u16 => Err(Error::ErrorResponse(
13023                ResponseValue::from_response(response).await?,
13024            )),
13025            500u16..=599u16 => Err(Error::ErrorResponse(
13026                ResponseValue::from_response(response).await?,
13027            )),
13028            _ => Err(Error::UnexpectedResponse(response)),
13029        }
13030    }
13031
13032    ///Forget cached paths
13033    ///
13034    ///Evicts specific files or directories from the VFS directory cache.
13035    ///
13036    ///Sends a `POST` request to `/vfs/forget`
13037    ///
13038    ///Arguments:
13039    /// - `async_`: Run the command asynchronously. Returns a job id
13040    ///   immediately.
13041    /// - `group`: Assign the request to a custom stats group.
13042    /// - `fs`: Optional VFS identifier to target; required when more than one
13043    ///   VFS is active.
13044    /// - `params`: Additional arbitrary parameters allowed.
13045    pub async fn vfs_forget<'a>(
13046        &'a self,
13047        async_: Option<bool>,
13048        group: Option<&'a str>,
13049        fs: Option<&'a str>,
13050        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13051    ) -> Result<ResponseValue<types::VfsForgetResponse>, Error<types::RcError>> {
13052        let url = format!("{}/vfs/forget", self.baseurl,);
13053        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13054        header_map.append(
13055            ::reqwest::header::HeaderName::from_static("api-version"),
13056            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13057        );
13058        #[allow(unused_mut)]
13059        let mut request = self
13060            .client
13061            .post(url)
13062            .header(
13063                ::reqwest::header::ACCEPT,
13064                ::reqwest::header::HeaderValue::from_static("application/json"),
13065            )
13066            .query(&progenitor_client::QueryParam::new("_async", &async_))
13067            .query(&progenitor_client::QueryParam::new("_group", &group))
13068            .query(&progenitor_client::QueryParam::new("fs", &fs))
13069            .query(&progenitor_client::QueryParam::new("params", &params))
13070            .headers(header_map)
13071            .build()?;
13072        let info = OperationInfo {
13073            operation_id: "vfs_forget",
13074        };
13075        self.pre(&mut request, &info).await?;
13076        let result = self.exec(request, &info).await;
13077        self.post(&result, &info).await?;
13078        let response = result?;
13079        match response.status().as_u16() {
13080            200u16 => ResponseValue::from_response(response).await,
13081            400u16..=499u16 => Err(Error::ErrorResponse(
13082                ResponseValue::from_response(response).await?,
13083            )),
13084            500u16..=599u16 => Err(Error::ErrorResponse(
13085                ResponseValue::from_response(response).await?,
13086            )),
13087            _ => Err(Error::UnexpectedResponse(response)),
13088        }
13089    }
13090
13091    ///List VFS instances
13092    ///
13093    ///Lists the active VFS instances and their identifiers.
13094    ///
13095    ///Sends a `POST` request to `/vfs/list`
13096    ///
13097    ///Arguments:
13098    /// - `async_`: Run the command asynchronously. Returns a job id
13099    ///   immediately.
13100    /// - `group`: Assign the request to a custom stats group.
13101    /// - `fs`: Optional VFS identifier; omit to list all active VFS instances.
13102    pub async fn vfs_list<'a>(
13103        &'a self,
13104        async_: Option<bool>,
13105        group: Option<&'a str>,
13106        fs: Option<&'a str>,
13107    ) -> Result<ResponseValue<types::VfsListResponse>, Error<types::RcError>> {
13108        let url = format!("{}/vfs/list", self.baseurl,);
13109        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13110        header_map.append(
13111            ::reqwest::header::HeaderName::from_static("api-version"),
13112            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13113        );
13114        #[allow(unused_mut)]
13115        let mut request = self
13116            .client
13117            .post(url)
13118            .header(
13119                ::reqwest::header::ACCEPT,
13120                ::reqwest::header::HeaderValue::from_static("application/json"),
13121            )
13122            .query(&progenitor_client::QueryParam::new("_async", &async_))
13123            .query(&progenitor_client::QueryParam::new("_group", &group))
13124            .query(&progenitor_client::QueryParam::new("fs", &fs))
13125            .headers(header_map)
13126            .build()?;
13127        let info = OperationInfo {
13128            operation_id: "vfs_list",
13129        };
13130        self.pre(&mut request, &info).await?;
13131        let result = self.exec(request, &info).await;
13132        self.post(&result, &info).await?;
13133        let response = result?;
13134        match response.status().as_u16() {
13135            200u16 => ResponseValue::from_response(response).await,
13136            400u16..=499u16 => Err(Error::ErrorResponse(
13137                ResponseValue::from_response(response).await?,
13138            )),
13139            500u16..=599u16 => Err(Error::ErrorResponse(
13140                ResponseValue::from_response(response).await?,
13141            )),
13142            _ => Err(Error::UnexpectedResponse(response)),
13143        }
13144    }
13145
13146    ///Get or set poll interval
13147    ///
13148    ///Reads or updates the VFS poll interval duration, optionally waiting for
13149    /// the change to apply.
13150    ///
13151    ///Sends a `POST` request to `/vfs/poll-interval`
13152    ///
13153    ///Arguments:
13154    /// - `async_`: Run the command asynchronously. Returns a job id
13155    ///   immediately.
13156    /// - `group`: Assign the request to a custom stats group.
13157    /// - `fs`: Optional VFS identifier whose poll interval should be queried or
13158    ///   modified.
13159    /// - `interval`: Duration string (e.g. `5m`) to set as the new poll
13160    ///   interval.
13161    /// - `timeout`: Duration to wait for the poll interval change to take
13162    ///   effect; `0` waits indefinitely.
13163    pub async fn vfs_poll_interval<'a>(
13164        &'a self,
13165        async_: Option<bool>,
13166        group: Option<&'a str>,
13167        fs: Option<&'a str>,
13168        interval: Option<&'a str>,
13169        timeout: Option<&'a str>,
13170    ) -> Result<
13171        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13172        Error<types::RcError>,
13173    > {
13174        let url = format!("{}/vfs/poll-interval", self.baseurl,);
13175        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13176        header_map.append(
13177            ::reqwest::header::HeaderName::from_static("api-version"),
13178            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13179        );
13180        #[allow(unused_mut)]
13181        let mut request = self
13182            .client
13183            .post(url)
13184            .header(
13185                ::reqwest::header::ACCEPT,
13186                ::reqwest::header::HeaderValue::from_static("application/json"),
13187            )
13188            .query(&progenitor_client::QueryParam::new("_async", &async_))
13189            .query(&progenitor_client::QueryParam::new("_group", &group))
13190            .query(&progenitor_client::QueryParam::new("fs", &fs))
13191            .query(&progenitor_client::QueryParam::new("interval", &interval))
13192            .query(&progenitor_client::QueryParam::new("timeout", &timeout))
13193            .headers(header_map)
13194            .build()?;
13195        let info = OperationInfo {
13196            operation_id: "vfs_poll_interval",
13197        };
13198        self.pre(&mut request, &info).await?;
13199        let result = self.exec(request, &info).await;
13200        self.post(&result, &info).await?;
13201        let response = result?;
13202        match response.status().as_u16() {
13203            200u16 => ResponseValue::from_response(response).await,
13204            400u16..=499u16 => Err(Error::ErrorResponse(
13205                ResponseValue::from_response(response).await?,
13206            )),
13207            500u16..=599u16 => Err(Error::ErrorResponse(
13208                ResponseValue::from_response(response).await?,
13209            )),
13210            _ => Err(Error::UnexpectedResponse(response)),
13211        }
13212    }
13213
13214    ///Inspect upload queue
13215    ///
13216    ///Returns the contents of the VFS upload queue.
13217    ///
13218    ///Sends a `POST` request to `/vfs/queue`
13219    ///
13220    ///Arguments:
13221    /// - `async_`: Run the command asynchronously. Returns a job id
13222    ///   immediately.
13223    /// - `group`: Assign the request to a custom stats group.
13224    /// - `fs`: Optional VFS identifier whose upload queue should be inspected.
13225    pub async fn vfs_queue<'a>(
13226        &'a self,
13227        async_: Option<bool>,
13228        group: Option<&'a str>,
13229        fs: Option<&'a str>,
13230    ) -> Result<ResponseValue<types::VfsQueueResponse>, Error<types::RcError>> {
13231        let url = format!("{}/vfs/queue", self.baseurl,);
13232        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13233        header_map.append(
13234            ::reqwest::header::HeaderName::from_static("api-version"),
13235            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13236        );
13237        #[allow(unused_mut)]
13238        let mut request = self
13239            .client
13240            .post(url)
13241            .header(
13242                ::reqwest::header::ACCEPT,
13243                ::reqwest::header::HeaderValue::from_static("application/json"),
13244            )
13245            .query(&progenitor_client::QueryParam::new("_async", &async_))
13246            .query(&progenitor_client::QueryParam::new("_group", &group))
13247            .query(&progenitor_client::QueryParam::new("fs", &fs))
13248            .headers(header_map)
13249            .build()?;
13250        let info = OperationInfo {
13251            operation_id: "vfs_queue",
13252        };
13253        self.pre(&mut request, &info).await?;
13254        let result = self.exec(request, &info).await;
13255        self.post(&result, &info).await?;
13256        let response = result?;
13257        match response.status().as_u16() {
13258            200u16 => ResponseValue::from_response(response).await,
13259            400u16..=499u16 => Err(Error::ErrorResponse(
13260                ResponseValue::from_response(response).await?,
13261            )),
13262            500u16..=599u16 => Err(Error::ErrorResponse(
13263                ResponseValue::from_response(response).await?,
13264            )),
13265            _ => Err(Error::UnexpectedResponse(response)),
13266        }
13267    }
13268
13269    ///Adjust queue expiry
13270    ///
13271    ///Sets the expiry time of a queued VFS upload item, optionally relative to
13272    /// its current value.
13273    ///
13274    ///Sends a `POST` request to `/vfs/queue-set-expiry`
13275    ///
13276    ///Arguments:
13277    /// - `async_`: Run the command asynchronously. Returns a job id
13278    ///   immediately.
13279    /// - `group`: Assign the request to a custom stats group.
13280    /// - `expiry`: New eligibility time in seconds (may be negative for
13281    ///   immediate upload).
13282    /// - `fs`: Optional VFS identifier for the queued item.
13283    /// - `id`: Queue item ID as returned by `vfs/queue`.
13284    /// - `relative`: Set to true to treat `expiry` as relative to the current
13285    ///   value.
13286    pub async fn vfs_queue_set_expiry<'a>(
13287        &'a self,
13288        async_: Option<bool>,
13289        group: Option<&'a str>,
13290        expiry: f64,
13291        fs: Option<&'a str>,
13292        id: i64,
13293        relative: Option<bool>,
13294    ) -> Result<
13295        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13296        Error<types::RcError>,
13297    > {
13298        let url = format!("{}/vfs/queue-set-expiry", self.baseurl,);
13299        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13300        header_map.append(
13301            ::reqwest::header::HeaderName::from_static("api-version"),
13302            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13303        );
13304        #[allow(unused_mut)]
13305        let mut request = self
13306            .client
13307            .post(url)
13308            .header(
13309                ::reqwest::header::ACCEPT,
13310                ::reqwest::header::HeaderValue::from_static("application/json"),
13311            )
13312            .query(&progenitor_client::QueryParam::new("_async", &async_))
13313            .query(&progenitor_client::QueryParam::new("_group", &group))
13314            .query(&progenitor_client::QueryParam::new("expiry", &expiry))
13315            .query(&progenitor_client::QueryParam::new("fs", &fs))
13316            .query(&progenitor_client::QueryParam::new("id", &id))
13317            .query(&progenitor_client::QueryParam::new("relative", &relative))
13318            .headers(header_map)
13319            .build()?;
13320        let info = OperationInfo {
13321            operation_id: "vfs_queue_set_expiry",
13322        };
13323        self.pre(&mut request, &info).await?;
13324        let result = self.exec(request, &info).await;
13325        self.post(&result, &info).await?;
13326        let response = result?;
13327        match response.status().as_u16() {
13328            200u16 => ResponseValue::from_response(response).await,
13329            400u16..=499u16 => Err(Error::ErrorResponse(
13330                ResponseValue::from_response(response).await?,
13331            )),
13332            500u16..=599u16 => Err(Error::ErrorResponse(
13333                ResponseValue::from_response(response).await?,
13334            )),
13335            _ => Err(Error::UnexpectedResponse(response)),
13336        }
13337    }
13338
13339    ///Refresh directory cache
13340    ///
13341    ///Refreshes one or more directories in the VFS cache, optionally
13342    /// recursively.
13343    ///
13344    ///Sends a `POST` request to `/vfs/refresh`
13345    ///
13346    ///Arguments:
13347    /// - `async_`: Run the command asynchronously. Returns a job id
13348    ///   immediately.
13349    /// - `group`: Assign the request to a custom stats group.
13350    /// - `fs`: Optional VFS identifier whose directory cache should be
13351    ///   refreshed.
13352    /// - `params`: Additional arbitrary parameters allowed.
13353    /// - `recursive`: Set to true to refresh entire directory trees.
13354    pub async fn vfs_refresh<'a>(
13355        &'a self,
13356        async_: Option<bool>,
13357        group: Option<&'a str>,
13358        fs: Option<&'a str>,
13359        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13360        recursive: Option<bool>,
13361    ) -> Result<ResponseValue<types::VfsRefreshResponse>, Error<types::RcError>> {
13362        let url = format!("{}/vfs/refresh", self.baseurl,);
13363        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13364        header_map.append(
13365            ::reqwest::header::HeaderName::from_static("api-version"),
13366            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13367        );
13368        #[allow(unused_mut)]
13369        let mut request = self
13370            .client
13371            .post(url)
13372            .header(
13373                ::reqwest::header::ACCEPT,
13374                ::reqwest::header::HeaderValue::from_static("application/json"),
13375            )
13376            .query(&progenitor_client::QueryParam::new("_async", &async_))
13377            .query(&progenitor_client::QueryParam::new("_group", &group))
13378            .query(&progenitor_client::QueryParam::new("fs", &fs))
13379            .query(&progenitor_client::QueryParam::new("params", &params))
13380            .query(&progenitor_client::QueryParam::new("recursive", &recursive))
13381            .headers(header_map)
13382            .build()?;
13383        let info = OperationInfo {
13384            operation_id: "vfs_refresh",
13385        };
13386        self.pre(&mut request, &info).await?;
13387        let result = self.exec(request, &info).await;
13388        self.post(&result, &info).await?;
13389        let response = result?;
13390        match response.status().as_u16() {
13391            200u16 => ResponseValue::from_response(response).await,
13392            400u16..=499u16 => Err(Error::ErrorResponse(
13393                ResponseValue::from_response(response).await?,
13394            )),
13395            500u16..=599u16 => Err(Error::ErrorResponse(
13396                ResponseValue::from_response(response).await?,
13397            )),
13398            _ => Err(Error::UnexpectedResponse(response)),
13399        }
13400    }
13401
13402    ///Show VFS stats
13403    ///
13404    ///Returns VFS statistics including disk cache usage and metadata cache
13405    /// counters.
13406    ///
13407    ///Sends a `POST` request to `/vfs/stats`
13408    ///
13409    ///Arguments:
13410    /// - `async_`: Run the command asynchronously. Returns a job id
13411    ///   immediately.
13412    /// - `group`: Assign the request to a custom stats group.
13413    /// - `fs`: Optional VFS identifier whose statistics should be returned.
13414    pub async fn vfs_stats<'a>(
13415        &'a self,
13416        async_: Option<bool>,
13417        group: Option<&'a str>,
13418        fs: Option<&'a str>,
13419    ) -> Result<ResponseValue<types::VfsStatsResponse>, Error<types::RcError>> {
13420        let url = format!("{}/vfs/stats", self.baseurl,);
13421        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13422        header_map.append(
13423            ::reqwest::header::HeaderName::from_static("api-version"),
13424            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13425        );
13426        #[allow(unused_mut)]
13427        let mut request = self
13428            .client
13429            .post(url)
13430            .header(
13431                ::reqwest::header::ACCEPT,
13432                ::reqwest::header::HeaderValue::from_static("application/json"),
13433            )
13434            .query(&progenitor_client::QueryParam::new("_async", &async_))
13435            .query(&progenitor_client::QueryParam::new("_group", &group))
13436            .query(&progenitor_client::QueryParam::new("fs", &fs))
13437            .headers(header_map)
13438            .build()?;
13439        let info = OperationInfo {
13440            operation_id: "vfs_stats",
13441        };
13442        self.pre(&mut request, &info).await?;
13443        let result = self.exec(request, &info).await;
13444        self.post(&result, &info).await?;
13445        let response = result?;
13446        match response.status().as_u16() {
13447            200u16 => ResponseValue::from_response(response).await,
13448            400u16..=499u16 => Err(Error::ErrorResponse(
13449                ResponseValue::from_response(response).await?,
13450            )),
13451            500u16..=599u16 => Err(Error::ErrorResponse(
13452                ResponseValue::from_response(response).await?,
13453            )),
13454            _ => Err(Error::UnexpectedResponse(response)),
13455        }
13456    }
13457
13458    ///Install plugin
13459    ///
13460    ///Downloads and installs a plugin into the WebUI from the provided
13461    /// repository URL.
13462    ///
13463    ///Sends a `POST` request to `/pluginsctl/addPlugin`
13464    ///
13465    ///Arguments:
13466    /// - `async_`: Run the command asynchronously. Returns a job id
13467    ///   immediately.
13468    /// - `group`: Assign the request to a custom stats group.
13469    /// - `url`: Repository URL of the plugin to install.
13470    pub async fn pluginsctl_add_plugin<'a>(
13471        &'a self,
13472        async_: Option<bool>,
13473        group: Option<&'a str>,
13474        url: &'a str,
13475    ) -> Result<
13476        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13477        Error<types::RcError>,
13478    > {
13479        let _url = format!("{}/pluginsctl/addPlugin", self.baseurl,);
13480        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13481        header_map.append(
13482            ::reqwest::header::HeaderName::from_static("api-version"),
13483            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13484        );
13485        #[allow(unused_mut)]
13486        let mut request = self
13487            .client
13488            .post(_url)
13489            .header(
13490                ::reqwest::header::ACCEPT,
13491                ::reqwest::header::HeaderValue::from_static("application/json"),
13492            )
13493            .query(&progenitor_client::QueryParam::new("_async", &async_))
13494            .query(&progenitor_client::QueryParam::new("_group", &group))
13495            .query(&progenitor_client::QueryParam::new("url", &url))
13496            .headers(header_map)
13497            .build()?;
13498        let info = OperationInfo {
13499            operation_id: "pluginsctl_add_plugin",
13500        };
13501        self.pre(&mut request, &info).await?;
13502        let result = self.exec(request, &info).await;
13503        self.post(&result, &info).await?;
13504        let response = result?;
13505        match response.status().as_u16() {
13506            200u16 => ResponseValue::from_response(response).await,
13507            400u16..=499u16 => Err(Error::ErrorResponse(
13508                ResponseValue::from_response(response).await?,
13509            )),
13510            500u16..=599u16 => Err(Error::ErrorResponse(
13511                ResponseValue::from_response(response).await?,
13512            )),
13513            _ => Err(Error::UnexpectedResponse(response)),
13514        }
13515    }
13516
13517    ///Filter plugins by MIME type
13518    ///
13519    ///Returns plugins matching the requested MIME type and optional plugin
13520    /// type.
13521    ///
13522    ///Sends a `POST` request to `/pluginsctl/getPluginsForType`
13523    ///
13524    ///Arguments:
13525    /// - `async_`: Run the command asynchronously. Returns a job id
13526    ///   immediately.
13527    /// - `group`: Assign the request to a custom stats group.
13528    /// - `plugin_type`: Filter results by plugin type (e.g. `test`).
13529    /// - `type_`: MIME type to match when listing plugins.
13530    pub async fn pluginsctl_get_plugins_for_type<'a>(
13531        &'a self,
13532        async_: Option<bool>,
13533        group: Option<&'a str>,
13534        plugin_type: Option<&'a str>,
13535        type_: Option<&'a str>,
13536    ) -> Result<ResponseValue<types::PluginsctlGetPluginsForTypeResponse>, Error<types::RcError>>
13537    {
13538        let url = format!("{}/pluginsctl/getPluginsForType", self.baseurl,);
13539        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13540        header_map.append(
13541            ::reqwest::header::HeaderName::from_static("api-version"),
13542            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13543        );
13544        #[allow(unused_mut)]
13545        let mut request = self
13546            .client
13547            .post(url)
13548            .header(
13549                ::reqwest::header::ACCEPT,
13550                ::reqwest::header::HeaderValue::from_static("application/json"),
13551            )
13552            .query(&progenitor_client::QueryParam::new("_async", &async_))
13553            .query(&progenitor_client::QueryParam::new("_group", &group))
13554            .query(&progenitor_client::QueryParam::new(
13555                "pluginType",
13556                &plugin_type,
13557            ))
13558            .query(&progenitor_client::QueryParam::new("type", &type_))
13559            .headers(header_map)
13560            .build()?;
13561        let info = OperationInfo {
13562            operation_id: "pluginsctl_get_plugins_for_type",
13563        };
13564        self.pre(&mut request, &info).await?;
13565        let result = self.exec(request, &info).await;
13566        self.post(&result, &info).await?;
13567        let response = result?;
13568        match response.status().as_u16() {
13569            200u16 => ResponseValue::from_response(response).await,
13570            400u16..=499u16 => Err(Error::ErrorResponse(
13571                ResponseValue::from_response(response).await?,
13572            )),
13573            500u16..=599u16 => Err(Error::ErrorResponse(
13574                ResponseValue::from_response(response).await?,
13575            )),
13576            _ => Err(Error::UnexpectedResponse(response)),
13577        }
13578    }
13579
13580    ///List installed plugins
13581    ///
13582    ///Returns metadata for installed production and test plugins.
13583    ///
13584    ///Sends a `POST` request to `/pluginsctl/listPlugins`
13585    ///
13586    ///Arguments:
13587    /// - `async_`: Run the command asynchronously. Returns a job id
13588    ///   immediately.
13589    /// - `group`: Assign the request to a custom stats group.
13590    pub async fn pluginsctl_list_plugins<'a>(
13591        &'a self,
13592        async_: Option<bool>,
13593        group: Option<&'a str>,
13594    ) -> Result<ResponseValue<types::PluginsctlListPluginsResponse>, Error<types::RcError>> {
13595        let url = format!("{}/pluginsctl/listPlugins", self.baseurl,);
13596        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13597        header_map.append(
13598            ::reqwest::header::HeaderName::from_static("api-version"),
13599            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13600        );
13601        #[allow(unused_mut)]
13602        let mut request = self
13603            .client
13604            .post(url)
13605            .header(
13606                ::reqwest::header::ACCEPT,
13607                ::reqwest::header::HeaderValue::from_static("application/json"),
13608            )
13609            .query(&progenitor_client::QueryParam::new("_async", &async_))
13610            .query(&progenitor_client::QueryParam::new("_group", &group))
13611            .headers(header_map)
13612            .build()?;
13613        let info = OperationInfo {
13614            operation_id: "pluginsctl_list_plugins",
13615        };
13616        self.pre(&mut request, &info).await?;
13617        let result = self.exec(request, &info).await;
13618        self.post(&result, &info).await?;
13619        let response = result?;
13620        match response.status().as_u16() {
13621            200u16 => ResponseValue::from_response(response).await,
13622            400u16..=499u16 => Err(Error::ErrorResponse(
13623                ResponseValue::from_response(response).await?,
13624            )),
13625            500u16..=599u16 => Err(Error::ErrorResponse(
13626                ResponseValue::from_response(response).await?,
13627            )),
13628            _ => Err(Error::UnexpectedResponse(response)),
13629        }
13630    }
13631
13632    ///List installed test plugins
13633    ///
13634    ///Returns metadata for installed test plugins.
13635    ///
13636    ///Sends a `POST` request to `/pluginsctl/listTestPlugins`
13637    ///
13638    ///Arguments:
13639    /// - `async_`: Run the command asynchronously. Returns a job id
13640    ///   immediately.
13641    /// - `group`: Assign the request to a custom stats group.
13642    pub async fn pluginsctl_list_test_plugins<'a>(
13643        &'a self,
13644        async_: Option<bool>,
13645        group: Option<&'a str>,
13646    ) -> Result<ResponseValue<types::PluginsctlListTestPluginsResponse>, Error<types::RcError>>
13647    {
13648        let url = format!("{}/pluginsctl/listTestPlugins", self.baseurl,);
13649        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13650        header_map.append(
13651            ::reqwest::header::HeaderName::from_static("api-version"),
13652            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13653        );
13654        #[allow(unused_mut)]
13655        let mut request = self
13656            .client
13657            .post(url)
13658            .header(
13659                ::reqwest::header::ACCEPT,
13660                ::reqwest::header::HeaderValue::from_static("application/json"),
13661            )
13662            .query(&progenitor_client::QueryParam::new("_async", &async_))
13663            .query(&progenitor_client::QueryParam::new("_group", &group))
13664            .headers(header_map)
13665            .build()?;
13666        let info = OperationInfo {
13667            operation_id: "pluginsctl_list_test_plugins",
13668        };
13669        self.pre(&mut request, &info).await?;
13670        let result = self.exec(request, &info).await;
13671        self.post(&result, &info).await?;
13672        let response = result?;
13673        match response.status().as_u16() {
13674            200u16 => ResponseValue::from_response(response).await,
13675            400u16..=499u16 => Err(Error::ErrorResponse(
13676                ResponseValue::from_response(response).await?,
13677            )),
13678            500u16..=599u16 => Err(Error::ErrorResponse(
13679                ResponseValue::from_response(response).await?,
13680            )),
13681            _ => Err(Error::UnexpectedResponse(response)),
13682        }
13683    }
13684
13685    ///Remove plugin
13686    ///
13687    ///Uninstalls a plugin from the WebUI.
13688    ///
13689    ///Sends a `POST` request to `/pluginsctl/removePlugin`
13690    ///
13691    ///Arguments:
13692    /// - `async_`: Run the command asynchronously. Returns a job id
13693    ///   immediately.
13694    /// - `group`: Assign the request to a custom stats group.
13695    /// - `name`: Name of the plugin to uninstall.
13696    pub async fn pluginsctl_remove_plugin<'a>(
13697        &'a self,
13698        async_: Option<bool>,
13699        group: Option<&'a str>,
13700        name: &'a str,
13701    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
13702        let url = format!("{}/pluginsctl/removePlugin", self.baseurl,);
13703        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13704        header_map.append(
13705            ::reqwest::header::HeaderName::from_static("api-version"),
13706            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13707        );
13708        #[allow(unused_mut)]
13709        let mut request = self
13710            .client
13711            .post(url)
13712            .header(
13713                ::reqwest::header::ACCEPT,
13714                ::reqwest::header::HeaderValue::from_static("application/json"),
13715            )
13716            .query(&progenitor_client::QueryParam::new("_async", &async_))
13717            .query(&progenitor_client::QueryParam::new("_group", &group))
13718            .query(&progenitor_client::QueryParam::new("name", &name))
13719            .headers(header_map)
13720            .build()?;
13721        let info = OperationInfo {
13722            operation_id: "pluginsctl_remove_plugin",
13723        };
13724        self.pre(&mut request, &info).await?;
13725        let result = self.exec(request, &info).await;
13726        self.post(&result, &info).await?;
13727        let response = result?;
13728        match response.status().as_u16() {
13729            200u16 => Ok(ResponseValue::empty(response)),
13730            400u16..=499u16 => Err(Error::ErrorResponse(
13731                ResponseValue::from_response(response).await?,
13732            )),
13733            500u16..=599u16 => Err(Error::ErrorResponse(
13734                ResponseValue::from_response(response).await?,
13735            )),
13736            _ => Err(Error::UnexpectedResponse(response)),
13737        }
13738    }
13739
13740    ///Remove test plugin
13741    ///
13742    ///Uninstalls a test plugin from the WebUI.
13743    ///
13744    ///Sends a `POST` request to `/pluginsctl/removeTestPlugin`
13745    ///
13746    ///Arguments:
13747    /// - `async_`: Run the command asynchronously. Returns a job id
13748    ///   immediately.
13749    /// - `group`: Assign the request to a custom stats group.
13750    /// - `name`: Name of the test plugin to uninstall.
13751    pub async fn pluginsctl_remove_test_plugin<'a>(
13752        &'a self,
13753        async_: Option<bool>,
13754        group: Option<&'a str>,
13755        name: &'a str,
13756    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
13757        let url = format!("{}/pluginsctl/removeTestPlugin", self.baseurl,);
13758        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13759        header_map.append(
13760            ::reqwest::header::HeaderName::from_static("api-version"),
13761            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13762        );
13763        #[allow(unused_mut)]
13764        let mut request = self
13765            .client
13766            .post(url)
13767            .header(
13768                ::reqwest::header::ACCEPT,
13769                ::reqwest::header::HeaderValue::from_static("application/json"),
13770            )
13771            .query(&progenitor_client::QueryParam::new("_async", &async_))
13772            .query(&progenitor_client::QueryParam::new("_group", &group))
13773            .query(&progenitor_client::QueryParam::new("name", &name))
13774            .headers(header_map)
13775            .build()?;
13776        let info = OperationInfo {
13777            operation_id: "pluginsctl_remove_test_plugin",
13778        };
13779        self.pre(&mut request, &info).await?;
13780        let result = self.exec(request, &info).await;
13781        self.post(&result, &info).await?;
13782        let response = result?;
13783        match response.status().as_u16() {
13784            200u16 => Ok(ResponseValue::empty(response)),
13785            400u16..=499u16 => Err(Error::ErrorResponse(
13786                ResponseValue::from_response(response).await?,
13787            )),
13788            500u16..=599u16 => Err(Error::ErrorResponse(
13789                ResponseValue::from_response(response).await?,
13790            )),
13791            _ => Err(Error::UnexpectedResponse(response)),
13792        }
13793    }
13794}
13795
13796/// Items consumers will typically use such as the Client.
13797pub mod prelude {
13798    #[allow(unused_imports)]
13799    pub use super::Client;
13800}
rclone_sdk/lib.rs

rclone_sdk/
lib.rs
