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    ///    "name",
84    ///    "type"
85    ///  ],
86    ///  "properties": {
87    ///    "name": {
88    ///      "type": "string"
89    ///    },
90    ///    "provider": {
91    ///      "type": "string"
92    ///    },
93    ///    "type": {
94    ///      "type": "string"
95    ///    }
96    ///  },
97    ///  "additionalProperties": true
98    ///}
99    /// ```
100    /// </details>
101    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
102    pub struct ConfigGetResponse {
103        pub name: ::std::string::String,
104        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
105        pub provider: ::std::option::Option<::std::string::String>,
106        #[serde(rename = "type")]
107        pub type_: ::std::string::String,
108    }
109
110    impl ::std::convert::From<&ConfigGetResponse> for ConfigGetResponse {
111        fn from(value: &ConfigGetResponse) -> Self {
112            value.clone()
113        }
114    }
115
116    ///`ConfigListremotesResponse`
117    ///
118    /// <details><summary>JSON schema</summary>
119    ///
120    /// ```json
121    ///{
122    ///  "type": "object",
123    ///  "required": [
124    ///    "remotes"
125    ///  ],
126    ///  "properties": {
127    ///    "remotes": {
128    ///      "type": "array",
129    ///      "items": {
130    ///        "type": "string"
131    ///      }
132    ///    }
133    ///  }
134    ///}
135    /// ```
136    /// </details>
137    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
138    pub struct ConfigListremotesResponse {
139        pub remotes: ::std::vec::Vec<::std::string::String>,
140    }
141
142    impl ::std::convert::From<&ConfigListremotesResponse> for ConfigListremotesResponse {
143        fn from(value: &ConfigListremotesResponse) -> Self {
144            value.clone()
145        }
146    }
147
148    ///`ConfigPathsResponse`
149    ///
150    /// <details><summary>JSON schema</summary>
151    ///
152    /// ```json
153    ///{
154    ///  "type": "object",
155    ///  "required": [
156    ///    "cache",
157    ///    "config",
158    ///    "temp"
159    ///  ],
160    ///  "properties": {
161    ///    "cache": {
162    ///      "type": "string"
163    ///    },
164    ///    "config": {
165    ///      "type": "string"
166    ///    },
167    ///    "temp": {
168    ///      "type": "string"
169    ///    }
170    ///  }
171    ///}
172    /// ```
173    /// </details>
174    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
175    pub struct ConfigPathsResponse {
176        pub cache: ::std::string::String,
177        pub config: ::std::string::String,
178        pub temp: ::std::string::String,
179    }
180
181    impl ::std::convert::From<&ConfigPathsResponse> for ConfigPathsResponse {
182        fn from(value: &ConfigPathsResponse) -> Self {
183            value.clone()
184        }
185    }
186
187    ///`ConfigProvider`
188    ///
189    /// <details><summary>JSON schema</summary>
190    ///
191    /// ```json
192    ///{
193    ///  "type": "object",
194    ///  "required": [
195    ///    "Description",
196    ///    "Name",
197    ///    "Options",
198    ///    "Prefix"
199    ///  ],
200    ///  "properties": {
201    ///    "Aliases": {
202    ///      "type": [
203    ///        "array",
204    ///        "null"
205    ///      ],
206    ///      "items": {
207    ///        "type": "string"
208    ///      }
209    ///    },
210    ///    "CommandHelp": {
211    ///      "type": [
212    ///        "array",
213    ///        "null"
214    ///      ],
215    ///      "items": {
216    ///        "$ref": "#/components/schemas/ConfigProviderCommandHelp"
217    ///      }
218    ///    },
219    ///    "Description": {
220    ///      "type": "string"
221    ///    },
222    ///    "Hide": {
223    ///      "type": "boolean"
224    ///    },
225    ///    "MetadataInfo": {
226    ///      "$ref": "#/components/schemas/ConfigProviderMetadataInfo"
227    ///    },
228    ///    "Name": {
229    ///      "type": "string"
230    ///    },
231    ///    "Options": {
232    ///      "type": "array",
233    ///      "items": {
234    ///        "$ref": "#/components/schemas/ConfigProviderOption"
235    ///      }
236    ///    },
237    ///    "Prefix": {
238    ///      "type": "string"
239    ///    }
240    ///  },
241    ///  "additionalProperties": true
242    ///}
243    /// ```
244    /// </details>
245    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
246    pub struct ConfigProvider {
247        #[serde(
248            rename = "Aliases",
249            default,
250            skip_serializing_if = "::std::option::Option::is_none"
251        )]
252        pub aliases: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
253        #[serde(
254            rename = "CommandHelp",
255            default,
256            skip_serializing_if = "::std::option::Option::is_none"
257        )]
258        pub command_help: ::std::option::Option<::std::vec::Vec<ConfigProviderCommandHelp>>,
259        #[serde(rename = "Description")]
260        pub description: ::std::string::String,
261        #[serde(
262            rename = "Hide",
263            default,
264            skip_serializing_if = "::std::option::Option::is_none"
265        )]
266        pub hide: ::std::option::Option<bool>,
267        #[serde(
268            rename = "MetadataInfo",
269            default,
270            skip_serializing_if = "::std::option::Option::is_none"
271        )]
272        pub metadata_info: ::std::option::Option<ConfigProviderMetadataInfo>,
273        #[serde(rename = "Name")]
274        pub name: ::std::string::String,
275        #[serde(rename = "Options")]
276        pub options: ::std::vec::Vec<ConfigProviderOption>,
277        #[serde(rename = "Prefix")]
278        pub prefix: ::std::string::String,
279    }
280
281    impl ::std::convert::From<&ConfigProvider> for ConfigProvider {
282        fn from(value: &ConfigProvider) -> Self {
283            value.clone()
284        }
285    }
286
287    ///`ConfigProviderCommandHelp`
288    ///
289    /// <details><summary>JSON schema</summary>
290    ///
291    /// ```json
292    ///{
293    ///  "type": "object",
294    ///  "properties": {
295    ///    "Long": {
296    ///      "type": "string"
297    ///    },
298    ///    "Name": {
299    ///      "type": "string"
300    ///    },
301    ///    "Opts": {
302    ///      "type": [
303    ///        "object",
304    ///        "null"
305    ///      ],
306    ///      "additionalProperties": true
307    ///    },
308    ///    "Short": {
309    ///      "type": "string"
310    ///    }
311    ///  },
312    ///  "additionalProperties": true
313    ///}
314    /// ```
315    /// </details>
316    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
317    pub struct ConfigProviderCommandHelp {
318        #[serde(
319            rename = "Long",
320            default,
321            skip_serializing_if = "::std::option::Option::is_none"
322        )]
323        pub long: ::std::option::Option<::std::string::String>,
324        #[serde(
325            rename = "Name",
326            default,
327            skip_serializing_if = "::std::option::Option::is_none"
328        )]
329        pub name: ::std::option::Option<::std::string::String>,
330        #[serde(
331            rename = "Opts",
332            default,
333            skip_serializing_if = "::std::option::Option::is_none"
334        )]
335        pub opts:
336            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
337        #[serde(
338            rename = "Short",
339            default,
340            skip_serializing_if = "::std::option::Option::is_none"
341        )]
342        pub short: ::std::option::Option<::std::string::String>,
343    }
344
345    impl ::std::convert::From<&ConfigProviderCommandHelp> for ConfigProviderCommandHelp {
346        fn from(value: &ConfigProviderCommandHelp) -> Self {
347            value.clone()
348        }
349    }
350
351    impl ::std::default::Default for ConfigProviderCommandHelp {
352        fn default() -> Self {
353            Self {
354                long: Default::default(),
355                name: Default::default(),
356                opts: Default::default(),
357                short: Default::default(),
358            }
359        }
360    }
361
362    ///`ConfigProviderMetadataInfo`
363    ///
364    /// <details><summary>JSON schema</summary>
365    ///
366    /// ```json
367    ///{
368    ///  "type": "object",
369    ///  "properties": {
370    ///    "Help": {
371    ///      "type": "string"
372    ///    },
373    ///    "System": {
374    ///      "type": [
375    ///        "object",
376    ///        "null"
377    ///      ],
378    ///      "additionalProperties": {
379    ///        "$ref": "#/components/schemas/ConfigProviderMetadataSystemEntry"
380    ///      }
381    ///    }
382    ///  },
383    ///  "additionalProperties": true
384    ///}
385    /// ```
386    /// </details>
387    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
388    pub struct ConfigProviderMetadataInfo {
389        #[serde(
390            rename = "Help",
391            default,
392            skip_serializing_if = "::std::option::Option::is_none"
393        )]
394        pub help: ::std::option::Option<::std::string::String>,
395        #[serde(
396            rename = "System",
397            default,
398            skip_serializing_if = "::std::option::Option::is_none"
399        )]
400        pub system: ::std::option::Option<
401            ::std::collections::HashMap<::std::string::String, ConfigProviderMetadataSystemEntry>,
402        >,
403    }
404
405    impl ::std::convert::From<&ConfigProviderMetadataInfo> for ConfigProviderMetadataInfo {
406        fn from(value: &ConfigProviderMetadataInfo) -> Self {
407            value.clone()
408        }
409    }
410
411    impl ::std::default::Default for ConfigProviderMetadataInfo {
412        fn default() -> Self {
413            Self {
414                help: Default::default(),
415                system: Default::default(),
416            }
417        }
418    }
419
420    ///`ConfigProviderMetadataSystemEntry`
421    ///
422    /// <details><summary>JSON schema</summary>
423    ///
424    /// ```json
425    ///{
426    ///  "type": "object",
427    ///  "properties": {
428    ///    "Example": {
429    ///      "type": "string"
430    ///    },
431    ///    "Help": {
432    ///      "type": "string"
433    ///    },
434    ///    "ReadOnly": {
435    ///      "type": "boolean"
436    ///    },
437    ///    "Type": {
438    ///      "type": "string"
439    ///    }
440    ///  },
441    ///  "additionalProperties": true
442    ///}
443    /// ```
444    /// </details>
445    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
446    pub struct ConfigProviderMetadataSystemEntry {
447        #[serde(
448            rename = "Example",
449            default,
450            skip_serializing_if = "::std::option::Option::is_none"
451        )]
452        pub example: ::std::option::Option<::std::string::String>,
453        #[serde(
454            rename = "Help",
455            default,
456            skip_serializing_if = "::std::option::Option::is_none"
457        )]
458        pub help: ::std::option::Option<::std::string::String>,
459        #[serde(
460            rename = "ReadOnly",
461            default,
462            skip_serializing_if = "::std::option::Option::is_none"
463        )]
464        pub read_only: ::std::option::Option<bool>,
465        #[serde(
466            rename = "Type",
467            default,
468            skip_serializing_if = "::std::option::Option::is_none"
469        )]
470        pub type_: ::std::option::Option<::std::string::String>,
471    }
472
473    impl ::std::convert::From<&ConfigProviderMetadataSystemEntry>
474        for ConfigProviderMetadataSystemEntry
475    {
476        fn from(value: &ConfigProviderMetadataSystemEntry) -> Self {
477            value.clone()
478        }
479    }
480
481    impl ::std::default::Default for ConfigProviderMetadataSystemEntry {
482        fn default() -> Self {
483            Self {
484                example: Default::default(),
485                help: Default::default(),
486                read_only: Default::default(),
487                type_: Default::default(),
488            }
489        }
490    }
491
492    ///`ConfigProviderOption`
493    ///
494    /// <details><summary>JSON schema</summary>
495    ///
496    /// ```json
497    ///{
498    ///  "type": "object",
499    ///  "required": [
500    ///    "Advanced",
501    ///    "Default",
502    ///    "DefaultStr",
503    ///    "Exclusive",
504    ///    "FieldName",
505    ///    "Help",
506    ///    "Hide",
507    ///    "IsPassword",
508    ///    "Name",
509    ///    "NoPrefix",
510    ///    "Required",
511    ///    "Sensitive",
512    ///    "Type",
513    ///    "Value",
514    ///    "ValueStr"
515    ///  ],
516    ///  "properties": {
517    ///    "Advanced": {
518    ///      "type": "boolean"
519    ///    },
520    ///    "Default": {
521    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
522    ///    },
523    ///    "DefaultStr": {
524    ///      "type": "string"
525    ///    },
526    ///    "Examples": {
527    ///      "type": "array",
528    ///      "items": {
529    ///        "$ref": "#/components/schemas/ConfigProviderOptionExample"
530    ///      }
531    ///    },
532    ///    "Exclusive": {
533    ///      "type": "boolean"
534    ///    },
535    ///    "FieldName": {
536    ///      "type": "string"
537    ///    },
538    ///    "Help": {
539    ///      "type": "string"
540    ///    },
541    ///    "Hide": {
542    ///      "type": "number"
543    ///    },
544    ///    "IsPassword": {
545    ///      "type": "boolean"
546    ///    },
547    ///    "Name": {
548    ///      "type": "string"
549    ///    },
550    ///    "NoPrefix": {
551    ///      "type": "boolean"
552    ///    },
553    ///    "Provider": {
554    ///      "type": "string"
555    ///    },
556    ///    "Required": {
557    ///      "type": "boolean"
558    ///    },
559    ///    "Sensitive": {
560    ///      "type": "boolean"
561    ///    },
562    ///    "ShortOpt": {
563    ///      "type": "string"
564    ///    },
565    ///    "Type": {
566    ///      "$ref": "#/components/schemas/ConfigProviderOptionType"
567    ///    },
568    ///    "Value": {
569    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
570    ///    },
571    ///    "ValueStr": {
572    ///      "type": "string"
573    ///    }
574    ///  },
575    ///  "additionalProperties": true
576    ///}
577    /// ```
578    /// </details>
579    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
580    pub struct ConfigProviderOption {
581        #[serde(rename = "Advanced")]
582        pub advanced: bool,
583        #[serde(rename = "Default")]
584        pub default: ConfigProviderOptionAny,
585        #[serde(rename = "DefaultStr")]
586        pub default_str: ::std::string::String,
587        #[serde(
588            rename = "Examples",
589            default,
590            skip_serializing_if = "::std::vec::Vec::is_empty"
591        )]
592        pub examples: ::std::vec::Vec<ConfigProviderOptionExample>,
593        #[serde(rename = "Exclusive")]
594        pub exclusive: bool,
595        #[serde(rename = "FieldName")]
596        pub field_name: ::std::string::String,
597        #[serde(rename = "Help")]
598        pub help: ::std::string::String,
599        #[serde(rename = "Hide")]
600        pub hide: f64,
601        #[serde(rename = "IsPassword")]
602        pub is_password: bool,
603        #[serde(rename = "Name")]
604        pub name: ::std::string::String,
605        #[serde(rename = "NoPrefix")]
606        pub no_prefix: bool,
607        #[serde(
608            rename = "Provider",
609            default,
610            skip_serializing_if = "::std::option::Option::is_none"
611        )]
612        pub provider: ::std::option::Option<::std::string::String>,
613        #[serde(rename = "Required")]
614        pub required: bool,
615        #[serde(rename = "Sensitive")]
616        pub sensitive: bool,
617        #[serde(
618            rename = "ShortOpt",
619            default,
620            skip_serializing_if = "::std::option::Option::is_none"
621        )]
622        pub short_opt: ::std::option::Option<::std::string::String>,
623        #[serde(rename = "Type")]
624        pub type_: ConfigProviderOptionType,
625        #[serde(rename = "Value")]
626        pub value: ConfigProviderOptionAny,
627        #[serde(rename = "ValueStr")]
628        pub value_str: ::std::string::String,
629    }
630
631    impl ::std::convert::From<&ConfigProviderOption> for ConfigProviderOption {
632        fn from(value: &ConfigProviderOption) -> Self {
633            value.clone()
634        }
635    }
636
637    ///Arbitrary JSON value. (arbitrary JSON value)
638    ///
639    /// <details><summary>JSON schema</summary>
640    ///
641    /// ```json
642    ///{
643    ///  "description": "Arbitrary JSON value. (arbitrary JSON value)",
644    ///  "type": [
645    ///    "object",
646    ///    "null"
647    ///  ],
648    ///  "additionalProperties": true
649    ///}
650    /// ```
651    /// </details>
652    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
653    #[serde(transparent)]
654    pub struct ConfigProviderOptionAny(
655        pub ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
656    );
657    impl ::std::ops::Deref for ConfigProviderOptionAny {
658        type Target =
659            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>;
660        fn deref(
661            &self,
662        ) -> &::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
663        {
664            &self.0
665        }
666    }
667
668    impl ::std::convert::From<ConfigProviderOptionAny>
669        for ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
670    {
671        fn from(value: ConfigProviderOptionAny) -> Self {
672            value.0
673        }
674    }
675
676    impl ::std::convert::From<&ConfigProviderOptionAny> for ConfigProviderOptionAny {
677        fn from(value: &ConfigProviderOptionAny) -> Self {
678            value.clone()
679        }
680    }
681
682    impl
683        ::std::convert::From<
684            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
685        > for ConfigProviderOptionAny
686    {
687        fn from(
688            value: ::std::option::Option<
689                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
690            >,
691        ) -> Self {
692            Self(value)
693        }
694    }
695
696    ///`ConfigProviderOptionExample`
697    ///
698    /// <details><summary>JSON schema</summary>
699    ///
700    /// ```json
701    ///{
702    ///  "type": "object",
703    ///  "required": [
704    ///    "Help",
705    ///    "Value"
706    ///  ],
707    ///  "properties": {
708    ///    "Help": {
709    ///      "type": "string"
710    ///    },
711    ///    "Provider": {
712    ///      "type": "string"
713    ///    },
714    ///    "Value": {
715    ///      "type": "string"
716    ///    }
717    ///  },
718    ///  "additionalProperties": true
719    ///}
720    /// ```
721    /// </details>
722    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
723    pub struct ConfigProviderOptionExample {
724        #[serde(rename = "Help")]
725        pub help: ::std::string::String,
726        #[serde(
727            rename = "Provider",
728            default,
729            skip_serializing_if = "::std::option::Option::is_none"
730        )]
731        pub provider: ::std::option::Option<::std::string::String>,
732        #[serde(rename = "Value")]
733        pub value: ::std::string::String,
734    }
735
736    impl ::std::convert::From<&ConfigProviderOptionExample> for ConfigProviderOptionExample {
737        fn from(value: &ConfigProviderOptionExample) -> Self {
738            value.clone()
739        }
740    }
741
742    ///`ConfigProviderOptionType`
743    ///
744    /// <details><summary>JSON schema</summary>
745    ///
746    /// ```json
747    ///{
748    ///  "type": "string",
749    ///  "enum": [
750    ///    "Bits",
751    ///    "bool",
752    ///    "CommaSepList",
753    ///    "Duration",
754    ///    "Encoding",
755    ///    "int",
756    ///    "mtime|atime|btime|ctime",
757    ///    "SizeSuffix",
758    ///    "SpaceSepList",
759    ///    "string",
760    ///    "stringArray",
761    ///    "Time",
762    ///    "Tristate"
763    ///  ]
764    ///}
765    /// ```
766    /// </details>
767    #[derive(
768        :: serde :: Deserialize,
769        :: serde :: Serialize,
770        Clone,
771        Copy,
772        Debug,
773        Eq,
774        Hash,
775        Ord,
776        PartialEq,
777        PartialOrd,
778    )]
779    pub enum ConfigProviderOptionType {
780        Bits,
781        #[serde(rename = "bool")]
782        Bool,
783        CommaSepList,
784        Duration,
785        Encoding,
786        #[serde(rename = "int")]
787        Int,
788        #[serde(rename = "mtime|atime|btime|ctime")]
789        MtimeAtimeBtimeCtime,
790        SizeSuffix,
791        SpaceSepList,
792        #[serde(rename = "string")]
793        String,
794        #[serde(rename = "stringArray")]
795        StringArray,
796        Time,
797        Tristate,
798    }
799
800    impl ::std::convert::From<&Self> for ConfigProviderOptionType {
801        fn from(value: &ConfigProviderOptionType) -> Self {
802            value.clone()
803        }
804    }
805
806    impl ::std::fmt::Display for ConfigProviderOptionType {
807        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
808            match *self {
809                Self::Bits => f.write_str("Bits"),
810                Self::Bool => f.write_str("bool"),
811                Self::CommaSepList => f.write_str("CommaSepList"),
812                Self::Duration => f.write_str("Duration"),
813                Self::Encoding => f.write_str("Encoding"),
814                Self::Int => f.write_str("int"),
815                Self::MtimeAtimeBtimeCtime => f.write_str("mtime|atime|btime|ctime"),
816                Self::SizeSuffix => f.write_str("SizeSuffix"),
817                Self::SpaceSepList => f.write_str("SpaceSepList"),
818                Self::String => f.write_str("string"),
819                Self::StringArray => f.write_str("stringArray"),
820                Self::Time => f.write_str("Time"),
821                Self::Tristate => f.write_str("Tristate"),
822            }
823        }
824    }
825
826    impl ::std::str::FromStr for ConfigProviderOptionType {
827        type Err = self::error::ConversionError;
828        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
829            match value {
830                "Bits" => Ok(Self::Bits),
831                "bool" => Ok(Self::Bool),
832                "CommaSepList" => Ok(Self::CommaSepList),
833                "Duration" => Ok(Self::Duration),
834                "Encoding" => Ok(Self::Encoding),
835                "int" => Ok(Self::Int),
836                "mtime|atime|btime|ctime" => Ok(Self::MtimeAtimeBtimeCtime),
837                "SizeSuffix" => Ok(Self::SizeSuffix),
838                "SpaceSepList" => Ok(Self::SpaceSepList),
839                "string" => Ok(Self::String),
840                "stringArray" => Ok(Self::StringArray),
841                "Time" => Ok(Self::Time),
842                "Tristate" => Ok(Self::Tristate),
843                _ => Err("invalid value".into()),
844            }
845        }
846    }
847
848    impl ::std::convert::TryFrom<&str> for ConfigProviderOptionType {
849        type Error = self::error::ConversionError;
850        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
851            value.parse()
852        }
853    }
854
855    impl ::std::convert::TryFrom<&::std::string::String> for ConfigProviderOptionType {
856        type Error = self::error::ConversionError;
857        fn try_from(
858            value: &::std::string::String,
859        ) -> ::std::result::Result<Self, self::error::ConversionError> {
860            value.parse()
861        }
862    }
863
864    impl ::std::convert::TryFrom<::std::string::String> for ConfigProviderOptionType {
865        type Error = self::error::ConversionError;
866        fn try_from(
867            value: ::std::string::String,
868        ) -> ::std::result::Result<Self, self::error::ConversionError> {
869            value.parse()
870        }
871    }
872
873    ///`ConfigProvidersResponse`
874    ///
875    /// <details><summary>JSON schema</summary>
876    ///
877    /// ```json
878    ///{
879    ///  "type": "object",
880    ///  "required": [
881    ///    "providers"
882    ///  ],
883    ///  "properties": {
884    ///    "providers": {
885    ///      "type": "array",
886    ///      "items": {
887    ///        "$ref": "#/components/schemas/ConfigProvider"
888    ///      }
889    ///    }
890    ///  },
891    ///  "additionalProperties": true
892    ///}
893    /// ```
894    /// </details>
895    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
896    pub struct ConfigProvidersResponse {
897        pub providers: ::std::vec::Vec<ConfigProvider>,
898    }
899
900    impl ::std::convert::From<&ConfigProvidersResponse> for ConfigProvidersResponse {
901        fn from(value: &ConfigProvidersResponse) -> Self {
902            value.clone()
903        }
904    }
905
906    ///`CoreBwlimitResponse`
907    ///
908    /// <details><summary>JSON schema</summary>
909    ///
910    /// ```json
911    ///{
912    ///  "type": "object",
913    ///  "required": [
914    ///    "bytesPerSecond",
915    ///    "bytesPerSecondRx",
916    ///    "bytesPerSecondTx",
917    ///    "rate"
918    ///  ],
919    ///  "properties": {
920    ///    "bytesPerSecond": {
921    ///      "type": "integer"
922    ///    },
923    ///    "bytesPerSecondRx": {
924    ///      "type": "integer"
925    ///    },
926    ///    "bytesPerSecondTx": {
927    ///      "type": "integer"
928    ///    },
929    ///    "rate": {
930    ///      "type": "string"
931    ///    }
932    ///  }
933    ///}
934    /// ```
935    /// </details>
936    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
937    pub struct CoreBwlimitResponse {
938        #[serde(rename = "bytesPerSecond")]
939        pub bytes_per_second: i64,
940        #[serde(rename = "bytesPerSecondRx")]
941        pub bytes_per_second_rx: i64,
942        #[serde(rename = "bytesPerSecondTx")]
943        pub bytes_per_second_tx: i64,
944        pub rate: ::std::string::String,
945    }
946
947    impl ::std::convert::From<&CoreBwlimitResponse> for CoreBwlimitResponse {
948        fn from(value: &CoreBwlimitResponse) -> Self {
949            value.clone()
950        }
951    }
952
953    ///`CoreCommandResponse`
954    ///
955    /// <details><summary>JSON schema</summary>
956    ///
957    /// ```json
958    ///{
959    ///  "type": "object",
960    ///  "required": [
961    ///    "error"
962    ///  ],
963    ///  "properties": {
964    ///    "error": {
965    ///      "type": "boolean"
966    ///    },
967    ///    "result": {
968    ///      "type": [
969    ///        "string",
970    ///        "null"
971    ///      ]
972    ///    },
973    ///    "returnType": {
974    ///      "type": [
975    ///        "string",
976    ///        "null"
977    ///      ]
978    ///    }
979    ///  }
980    ///}
981    /// ```
982    /// </details>
983    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
984    pub struct CoreCommandResponse {
985        pub error: bool,
986        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
987        pub result: ::std::option::Option<::std::string::String>,
988        #[serde(
989            rename = "returnType",
990            default,
991            skip_serializing_if = "::std::option::Option::is_none"
992        )]
993        pub return_type: ::std::option::Option<::std::string::String>,
994    }
995
996    impl ::std::convert::From<&CoreCommandResponse> for CoreCommandResponse {
997        fn from(value: &CoreCommandResponse) -> Self {
998            value.clone()
999        }
1000    }
1001
1002    ///`CoreDuResponse`
1003    ///
1004    /// <details><summary>JSON schema</summary>
1005    ///
1006    /// ```json
1007    ///{
1008    ///  "type": "object",
1009    ///  "required": [
1010    ///    "dir",
1011    ///    "info"
1012    ///  ],
1013    ///  "properties": {
1014    ///    "dir": {
1015    ///      "type": "string"
1016    ///    },
1017    ///    "info": {
1018    ///      "type": "object",
1019    ///      "required": [
1020    ///        "Available",
1021    ///        "Free",
1022    ///        "Total"
1023    ///      ],
1024    ///      "properties": {
1025    ///        "Available": {
1026    ///          "type": "integer"
1027    ///        },
1028    ///        "Free": {
1029    ///          "type": "integer"
1030    ///        },
1031    ///        "Total": {
1032    ///          "type": "integer"
1033    ///        }
1034    ///      }
1035    ///    }
1036    ///  }
1037    ///}
1038    /// ```
1039    /// </details>
1040    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1041    pub struct CoreDuResponse {
1042        pub dir: ::std::string::String,
1043        pub info: CoreDuResponseInfo,
1044    }
1045
1046    impl ::std::convert::From<&CoreDuResponse> for CoreDuResponse {
1047        fn from(value: &CoreDuResponse) -> Self {
1048            value.clone()
1049        }
1050    }
1051
1052    ///`CoreDuResponseInfo`
1053    ///
1054    /// <details><summary>JSON schema</summary>
1055    ///
1056    /// ```json
1057    ///{
1058    ///  "type": "object",
1059    ///  "required": [
1060    ///    "Available",
1061    ///    "Free",
1062    ///    "Total"
1063    ///  ],
1064    ///  "properties": {
1065    ///    "Available": {
1066    ///      "type": "integer"
1067    ///    },
1068    ///    "Free": {
1069    ///      "type": "integer"
1070    ///    },
1071    ///    "Total": {
1072    ///      "type": "integer"
1073    ///    }
1074    ///  }
1075    ///}
1076    /// ```
1077    /// </details>
1078    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1079    pub struct CoreDuResponseInfo {
1080        #[serde(rename = "Available")]
1081        pub available: i64,
1082        #[serde(rename = "Free")]
1083        pub free: i64,
1084        #[serde(rename = "Total")]
1085        pub total: i64,
1086    }
1087
1088    impl ::std::convert::From<&CoreDuResponseInfo> for CoreDuResponseInfo {
1089        fn from(value: &CoreDuResponseInfo) -> Self {
1090            value.clone()
1091        }
1092    }
1093
1094    ///`CoreGroupListResponse`
1095    ///
1096    /// <details><summary>JSON schema</summary>
1097    ///
1098    /// ```json
1099    ///{
1100    ///  "type": "object",
1101    ///  "required": [
1102    ///    "groups"
1103    ///  ],
1104    ///  "properties": {
1105    ///    "groups": {
1106    ///      "type": "array",
1107    ///      "items": {
1108    ///        "type": "string"
1109    ///      }
1110    ///    }
1111    ///  }
1112    ///}
1113    /// ```
1114    /// </details>
1115    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1116    pub struct CoreGroupListResponse {
1117        pub groups: ::std::vec::Vec<::std::string::String>,
1118    }
1119
1120    impl ::std::convert::From<&CoreGroupListResponse> for CoreGroupListResponse {
1121        fn from(value: &CoreGroupListResponse) -> Self {
1122            value.clone()
1123        }
1124    }
1125
1126    ///`CoreObscureResponse`
1127    ///
1128    /// <details><summary>JSON schema</summary>
1129    ///
1130    /// ```json
1131    ///{
1132    ///  "type": "object",
1133    ///  "required": [
1134    ///    "obscured"
1135    ///  ],
1136    ///  "properties": {
1137    ///    "obscured": {
1138    ///      "type": "string"
1139    ///    }
1140    ///  }
1141    ///}
1142    /// ```
1143    /// </details>
1144    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1145    pub struct CoreObscureResponse {
1146        pub obscured: ::std::string::String,
1147    }
1148
1149    impl ::std::convert::From<&CoreObscureResponse> for CoreObscureResponse {
1150        fn from(value: &CoreObscureResponse) -> Self {
1151            value.clone()
1152        }
1153    }
1154
1155    ///`CorePidResponse`
1156    ///
1157    /// <details><summary>JSON schema</summary>
1158    ///
1159    /// ```json
1160    ///{
1161    ///  "type": "object",
1162    ///  "required": [
1163    ///    "pid"
1164    ///  ],
1165    ///  "properties": {
1166    ///    "pid": {
1167    ///      "type": "integer"
1168    ///    }
1169    ///  }
1170    ///}
1171    /// ```
1172    /// </details>
1173    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1174    pub struct CorePidResponse {
1175        pub pid: i64,
1176    }
1177
1178    impl ::std::convert::From<&CorePidResponse> for CorePidResponse {
1179        fn from(value: &CorePidResponse) -> Self {
1180            value.clone()
1181        }
1182    }
1183
1184    ///Metadata for an item currently undergoing verification.
1185    ///
1186    /// <details><summary>JSON schema</summary>
1187    ///
1188    /// ```json
1189    ///{
1190    ///  "description": "Metadata for an item currently undergoing
1191    /// verification.",
1192    ///  "type": "object",
1193    ///  "properties": {
1194    ///    "group": {
1195    ///      "description": "Stats group name associated with this
1196    /// verification.",
1197    ///      "type": "string"
1198    ///    },
1199    ///    "name": {
1200    ///      "description": "Remote path of the object being verified.",
1201    ///      "type": "string"
1202    ///    },
1203    ///    "size": {
1204    ///      "description": "Total size in bytes of the object.",
1205    ///      "type": "number"
1206    ///    }
1207    ///  },
1208    ///  "additionalProperties": true
1209    ///}
1210    /// ```
1211    /// </details>
1212    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1213    pub struct CoreStatsChecking {
1214        ///Stats group name associated with this verification.
1215        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1216        pub group: ::std::option::Option<::std::string::String>,
1217        ///Remote path of the object being verified.
1218        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1219        pub name: ::std::option::Option<::std::string::String>,
1220        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1221        pub size: ::std::option::Option<f64>,
1222    }
1223
1224    impl ::std::convert::From<&CoreStatsChecking> for CoreStatsChecking {
1225        fn from(value: &CoreStatsChecking) -> Self {
1226            value.clone()
1227        }
1228    }
1229
1230    impl ::std::default::Default for CoreStatsChecking {
1231        fn default() -> Self {
1232            Self {
1233                group: Default::default(),
1234                name: Default::default(),
1235                size: Default::default(),
1236            }
1237        }
1238    }
1239
1240    ///`CoreStatsResponse`
1241    ///
1242    /// <details><summary>JSON schema</summary>
1243    ///
1244    /// ```json
1245    ///{
1246    ///  "type": "object",
1247    ///  "required": [
1248    ///    "bytes",
1249    ///    "checks",
1250    ///    "deletedDirs",
1251    ///    "deletes",
1252    ///    "elapsedTime",
1253    ///    "errors",
1254    ///    "fatalError",
1255    ///    "renames",
1256    ///    "retryError",
1257    ///    "serverSideCopies",
1258    ///    "serverSideCopyBytes",
1259    ///    "serverSideMoveBytes",
1260    ///    "serverSideMoves",
1261    ///    "speed",
1262    ///    "totalBytes",
1263    ///    "totalChecks",
1264    ///    "totalTransfers",
1265    ///    "transferTime",
1266    ///    "transfers"
1267    ///  ],
1268    ///  "properties": {
1269    ///    "bytes": {
1270    ///      "type": "number"
1271    ///    },
1272    ///    "checking": {
1273    ///      "description": "Objects currently undergoing verification
1274    /// operations.",
1275    ///      "type": "array",
1276    ///      "items": {
1277    ///        "$ref": "#/components/schemas/CoreStatsChecking"
1278    ///      }
1279    ///    },
1280    ///    "checks": {
1281    ///      "type": "number"
1282    ///    },
1283    ///    "deletedDirs": {
1284    ///      "type": "number"
1285    ///    },
1286    ///    "deletes": {
1287    ///      "type": "number"
1288    ///    },
1289    ///    "elapsedTime": {
1290    ///      "type": "number"
1291    ///    },
1292    ///    "errors": {
1293    ///      "type": "number"
1294    ///    },
1295    ///    "eta": {
1296    ///      "type": [
1297    ///        "number",
1298    ///        "null"
1299    ///      ]
1300    ///    },
1301    ///    "fatalError": {
1302    ///      "type": "boolean"
1303    ///    },
1304    ///    "lastError": {
1305    ///      "type": "string"
1306    ///    },
1307    ///    "listed": {
1308    ///      "type": "number"
1309    ///    },
1310    ///    "renames": {
1311    ///      "type": "number"
1312    ///    },
1313    ///    "retryError": {
1314    ///      "type": "boolean"
1315    ///    },
1316    ///    "serverSideCopies": {
1317    ///      "type": "number"
1318    ///    },
1319    ///    "serverSideCopyBytes": {
1320    ///      "type": "number"
1321    ///    },
1322    ///    "serverSideMoveBytes": {
1323    ///      "type": "number"
1324    ///    },
1325    ///    "serverSideMoves": {
1326    ///      "type": "number"
1327    ///    },
1328    ///    "speed": {
1329    ///      "type": "number"
1330    ///    },
1331    ///    "totalBytes": {
1332    ///      "type": "number"
1333    ///    },
1334    ///    "totalChecks": {
1335    ///      "type": "number"
1336    ///    },
1337    ///    "totalTransfers": {
1338    ///      "type": "number"
1339    ///    },
1340    ///    "transferTime": {
1341    ///      "type": "number"
1342    ///    },
1343    ///    "transferring": {
1344    ///      "description": "Active transfers currently in progress grouped by
1345    /// stats group.",
1346    ///      "type": "array",
1347    ///      "items": {
1348    ///        "$ref": "#/components/schemas/CoreStatsTransfer"
1349    ///      }
1350    ///    },
1351    ///    "transfers": {
1352    ///      "type": "number"
1353    ///    }
1354    ///  }
1355    ///}
1356    /// ```
1357    /// </details>
1358    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1359    pub struct CoreStatsResponse {
1360        pub bytes: f64,
1361        ///Objects currently undergoing verification operations.
1362        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1363        pub checking: ::std::vec::Vec<CoreStatsChecking>,
1364        pub checks: f64,
1365        #[serde(rename = "deletedDirs")]
1366        pub deleted_dirs: f64,
1367        pub deletes: f64,
1368        #[serde(rename = "elapsedTime")]
1369        pub elapsed_time: f64,
1370        pub errors: f64,
1371        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1372        pub eta: ::std::option::Option<f64>,
1373        #[serde(rename = "fatalError")]
1374        pub fatal_error: bool,
1375        #[serde(
1376            rename = "lastError",
1377            default,
1378            skip_serializing_if = "::std::option::Option::is_none"
1379        )]
1380        pub last_error: ::std::option::Option<::std::string::String>,
1381        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1382        pub listed: ::std::option::Option<f64>,
1383        pub renames: f64,
1384        #[serde(rename = "retryError")]
1385        pub retry_error: bool,
1386        #[serde(rename = "serverSideCopies")]
1387        pub server_side_copies: f64,
1388        #[serde(rename = "serverSideCopyBytes")]
1389        pub server_side_copy_bytes: f64,
1390        #[serde(rename = "serverSideMoveBytes")]
1391        pub server_side_move_bytes: f64,
1392        #[serde(rename = "serverSideMoves")]
1393        pub server_side_moves: f64,
1394        pub speed: f64,
1395        #[serde(rename = "totalBytes")]
1396        pub total_bytes: f64,
1397        #[serde(rename = "totalChecks")]
1398        pub total_checks: f64,
1399        #[serde(rename = "totalTransfers")]
1400        pub total_transfers: f64,
1401        #[serde(rename = "transferTime")]
1402        pub transfer_time: f64,
1403        ///Active transfers currently in progress grouped by stats group.
1404        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1405        pub transferring: ::std::vec::Vec<CoreStatsTransfer>,
1406        pub transfers: f64,
1407    }
1408
1409    impl ::std::convert::From<&CoreStatsResponse> for CoreStatsResponse {
1410        fn from(value: &CoreStatsResponse) -> Self {
1411            value.clone()
1412        }
1413    }
1414
1415    ///Progress metrics for an in-flight transfer.
1416    ///
1417    /// <details><summary>JSON schema</summary>
1418    ///
1419    /// ```json
1420    ///{
1421    ///  "description": "Progress metrics for an in-flight transfer.",
1422    ///  "type": "object",
1423    ///  "properties": {
1424    ///    "bytes": {
1425    ///      "description": "Bytes transferred so far for this object.",
1426    ///      "type": "number"
1427    ///    },
1428    ///    "eta": {
1429    ///      "description": "Estimated seconds remaining, when available.",
1430    ///      "type": [
1431    ///        "number",
1432    ///        "null"
1433    ///      ]
1434    ///    },
1435    ///    "group": {
1436    ///      "description": "Stats group name associated with this transfer.",
1437    ///      "type": "string"
1438    ///    },
1439    ///    "name": {
1440    ///      "description": "Remote path of the object being transferred.",
1441    ///      "type": "string"
1442    ///    },
1443    ///    "percentage": {
1444    ///      "description": "Completion percentage from 0-100.",
1445    ///      "type": "number"
1446    ///    },
1447    ///    "size": {
1448    ///      "description": "Total size in bytes of the object.",
1449    ///      "type": "number"
1450    ///    },
1451    ///    "speed": {
1452    ///      "description": "Current transfer speed in bytes per second.",
1453    ///      "type": "number"
1454    ///    },
1455    ///    "speedAvg": {
1456    ///      "description": "Current speed in bytes per second as an
1457    /// exponentially weighted moving average.",
1458    ///      "type": "number"
1459    ///    }
1460    ///  },
1461    ///  "additionalProperties": true
1462    ///}
1463    /// ```
1464    /// </details>
1465    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1466    pub struct CoreStatsTransfer {
1467        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1468        pub bytes: ::std::option::Option<f64>,
1469        ///Estimated seconds remaining, when available.
1470        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1471        pub eta: ::std::option::Option<f64>,
1472        ///Stats group name associated with this transfer.
1473        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1474        pub group: ::std::option::Option<::std::string::String>,
1475        ///Remote path of the object being transferred.
1476        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1477        pub name: ::std::option::Option<::std::string::String>,
1478        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1479        pub percentage: ::std::option::Option<f64>,
1480        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1481        pub size: ::std::option::Option<f64>,
1482        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1483        pub speed: ::std::option::Option<f64>,
1484        #[serde(
1485            rename = "speedAvg",
1486            default,
1487            skip_serializing_if = "::std::option::Option::is_none"
1488        )]
1489        pub speed_avg: ::std::option::Option<f64>,
1490    }
1491
1492    impl ::std::convert::From<&CoreStatsTransfer> for CoreStatsTransfer {
1493        fn from(value: &CoreStatsTransfer) -> Self {
1494            value.clone()
1495        }
1496    }
1497
1498    impl ::std::default::Default for CoreStatsTransfer {
1499        fn default() -> Self {
1500            Self {
1501                bytes: Default::default(),
1502                eta: Default::default(),
1503                group: Default::default(),
1504                name: Default::default(),
1505                percentage: Default::default(),
1506                size: Default::default(),
1507                speed: Default::default(),
1508                speed_avg: Default::default(),
1509            }
1510        }
1511    }
1512
1513    ///`CoreTransferredResponse`
1514    ///
1515    /// <details><summary>JSON schema</summary>
1516    ///
1517    /// ```json
1518    ///{
1519    ///  "type": "object",
1520    ///  "required": [
1521    ///    "transferred"
1522    ///  ],
1523    ///  "properties": {
1524    ///    "transferred": {
1525    ///      "type": "array",
1526    ///      "items": {
1527    ///        "type": "object",
1528    ///        "required": [
1529    ///          "group"
1530    ///        ],
1531    ///        "properties": {
1532    ///          "bytes": {
1533    ///            "type": "integer"
1534    ///          },
1535    ///          "checked": {
1536    ///            "type": "boolean"
1537    ///          },
1538    ///          "completed_at": {
1539    ///            "description": "ISO8601 timestamp when the transfer
1540    /// completed.",
1541    ///            "type": "string"
1542    ///          },
1543    ///          "dstFs": {
1544    ///            "description": "Destination remote or filesystem used for the
1545    /// transfer.",
1546    ///            "type": "string"
1547    ///          },
1548    ///          "dstRemote": {
1549    ///            "description": "Destination path within `dstFs`, when
1550    /// provided.",
1551    ///            "type": "string"
1552    ///          },
1553    ///          "error": {
1554    ///            "type": "string"
1555    ///          },
1556    ///          "group": {
1557    ///            "description": "Stats group identifier this transfer belonged
1558    /// to.",
1559    ///            "type": "string"
1560    ///          },
1561    ///          "jobid": {
1562    ///            "type": "integer"
1563    ///          },
1564    ///          "name": {
1565    ///            "type": "string"
1566    ///          },
1567    ///          "size": {
1568    ///            "type": "integer"
1569    ///          },
1570    ///          "srcFs": {
1571    ///            "description": "Source remote or filesystem used for the
1572    /// transfer.",
1573    ///            "type": "string"
1574    ///          },
1575    ///          "srcRemote": {
1576    ///            "description": "Source path within `srcFs`, when provided.",
1577    ///            "type": "string"
1578    ///          },
1579    ///          "started_at": {
1580    ///            "description": "ISO8601 timestamp when the transfer
1581    /// started.",
1582    ///            "type": "string"
1583    ///          },
1584    ///          "timestamp": {
1585    ///            "type": "integer"
1586    ///          },
1587    ///          "what": {
1588    ///            "type": "string",
1589    ///            "enum": [
1590    ///              "transferring",
1591    ///              "deleting",
1592    ///              "checking",
1593    ///              "importing",
1594    ///              "hashing",
1595    ///              "merging",
1596    ///              "listing",
1597    ///              "moving",
1598    ///              "renaming"
1599    ///            ]
1600    ///          }
1601    ///        },
1602    ///        "additionalProperties": true
1603    ///      }
1604    ///    }
1605    ///  }
1606    ///}
1607    /// ```
1608    /// </details>
1609    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1610    pub struct CoreTransferredResponse {
1611        pub transferred: ::std::vec::Vec<CoreTransferredResponseTransferredItem>,
1612    }
1613
1614    impl ::std::convert::From<&CoreTransferredResponse> for CoreTransferredResponse {
1615        fn from(value: &CoreTransferredResponse) -> Self {
1616            value.clone()
1617        }
1618    }
1619
1620    ///`CoreTransferredResponseTransferredItem`
1621    ///
1622    /// <details><summary>JSON schema</summary>
1623    ///
1624    /// ```json
1625    ///{
1626    ///  "type": "object",
1627    ///  "required": [
1628    ///    "group"
1629    ///  ],
1630    ///  "properties": {
1631    ///    "bytes": {
1632    ///      "type": "integer"
1633    ///    },
1634    ///    "checked": {
1635    ///      "type": "boolean"
1636    ///    },
1637    ///    "completed_at": {
1638    ///      "description": "ISO8601 timestamp when the transfer completed.",
1639    ///      "type": "string"
1640    ///    },
1641    ///    "dstFs": {
1642    ///      "description": "Destination remote or filesystem used for the
1643    /// transfer.",
1644    ///      "type": "string"
1645    ///    },
1646    ///    "dstRemote": {
1647    ///      "description": "Destination path within `dstFs`, when provided.",
1648    ///      "type": "string"
1649    ///    },
1650    ///    "error": {
1651    ///      "type": "string"
1652    ///    },
1653    ///    "group": {
1654    ///      "description": "Stats group identifier this transfer belonged to.",
1655    ///      "type": "string"
1656    ///    },
1657    ///    "jobid": {
1658    ///      "type": "integer"
1659    ///    },
1660    ///    "name": {
1661    ///      "type": "string"
1662    ///    },
1663    ///    "size": {
1664    ///      "type": "integer"
1665    ///    },
1666    ///    "srcFs": {
1667    ///      "description": "Source remote or filesystem used for the
1668    /// transfer.",
1669    ///      "type": "string"
1670    ///    },
1671    ///    "srcRemote": {
1672    ///      "description": "Source path within `srcFs`, when provided.",
1673    ///      "type": "string"
1674    ///    },
1675    ///    "started_at": {
1676    ///      "description": "ISO8601 timestamp when the transfer started.",
1677    ///      "type": "string"
1678    ///    },
1679    ///    "timestamp": {
1680    ///      "type": "integer"
1681    ///    },
1682    ///    "what": {
1683    ///      "type": "string",
1684    ///      "enum": [
1685    ///        "transferring",
1686    ///        "deleting",
1687    ///        "checking",
1688    ///        "importing",
1689    ///        "hashing",
1690    ///        "merging",
1691    ///        "listing",
1692    ///        "moving",
1693    ///        "renaming"
1694    ///      ]
1695    ///    }
1696    ///  },
1697    ///  "additionalProperties": true
1698    ///}
1699    /// ```
1700    /// </details>
1701    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1702    pub struct CoreTransferredResponseTransferredItem {
1703        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1704        pub bytes: ::std::option::Option<i64>,
1705        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1706        pub checked: ::std::option::Option<bool>,
1707        ///ISO8601 timestamp when the transfer completed.
1708        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1709        pub completed_at: ::std::option::Option<::std::string::String>,
1710        ///Destination remote or filesystem used for the transfer.
1711        #[serde(
1712            rename = "dstFs",
1713            default,
1714            skip_serializing_if = "::std::option::Option::is_none"
1715        )]
1716        pub dst_fs: ::std::option::Option<::std::string::String>,
1717        ///Destination path within `dstFs`, when provided.
1718        #[serde(
1719            rename = "dstRemote",
1720            default,
1721            skip_serializing_if = "::std::option::Option::is_none"
1722        )]
1723        pub dst_remote: ::std::option::Option<::std::string::String>,
1724        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1725        pub error: ::std::option::Option<::std::string::String>,
1726        ///Stats group identifier this transfer belonged to.
1727        pub group: ::std::string::String,
1728        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1729        pub jobid: ::std::option::Option<i64>,
1730        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1731        pub name: ::std::option::Option<::std::string::String>,
1732        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1733        pub size: ::std::option::Option<i64>,
1734        ///Source remote or filesystem used for the transfer.
1735        #[serde(
1736            rename = "srcFs",
1737            default,
1738            skip_serializing_if = "::std::option::Option::is_none"
1739        )]
1740        pub src_fs: ::std::option::Option<::std::string::String>,
1741        ///Source path within `srcFs`, when provided.
1742        #[serde(
1743            rename = "srcRemote",
1744            default,
1745            skip_serializing_if = "::std::option::Option::is_none"
1746        )]
1747        pub src_remote: ::std::option::Option<::std::string::String>,
1748        ///ISO8601 timestamp when the transfer started.
1749        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1750        pub started_at: ::std::option::Option<::std::string::String>,
1751        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1752        pub timestamp: ::std::option::Option<i64>,
1753        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1754        pub what: ::std::option::Option<CoreTransferredResponseTransferredItemWhat>,
1755    }
1756
1757    impl ::std::convert::From<&CoreTransferredResponseTransferredItem>
1758        for CoreTransferredResponseTransferredItem
1759    {
1760        fn from(value: &CoreTransferredResponseTransferredItem) -> Self {
1761            value.clone()
1762        }
1763    }
1764
1765    ///`CoreTransferredResponseTransferredItemWhat`
1766    ///
1767    /// <details><summary>JSON schema</summary>
1768    ///
1769    /// ```json
1770    ///{
1771    ///  "type": "string",
1772    ///  "enum": [
1773    ///    "transferring",
1774    ///    "deleting",
1775    ///    "checking",
1776    ///    "importing",
1777    ///    "hashing",
1778    ///    "merging",
1779    ///    "listing",
1780    ///    "moving",
1781    ///    "renaming"
1782    ///  ]
1783    ///}
1784    /// ```
1785    /// </details>
1786    #[derive(
1787        :: serde :: Deserialize,
1788        :: serde :: Serialize,
1789        Clone,
1790        Copy,
1791        Debug,
1792        Eq,
1793        Hash,
1794        Ord,
1795        PartialEq,
1796        PartialOrd,
1797    )]
1798    pub enum CoreTransferredResponseTransferredItemWhat {
1799        #[serde(rename = "transferring")]
1800        Transferring,
1801        #[serde(rename = "deleting")]
1802        Deleting,
1803        #[serde(rename = "checking")]
1804        Checking,
1805        #[serde(rename = "importing")]
1806        Importing,
1807        #[serde(rename = "hashing")]
1808        Hashing,
1809        #[serde(rename = "merging")]
1810        Merging,
1811        #[serde(rename = "listing")]
1812        Listing,
1813        #[serde(rename = "moving")]
1814        Moving,
1815        #[serde(rename = "renaming")]
1816        Renaming,
1817    }
1818
1819    impl ::std::convert::From<&Self> for CoreTransferredResponseTransferredItemWhat {
1820        fn from(value: &CoreTransferredResponseTransferredItemWhat) -> Self {
1821            value.clone()
1822        }
1823    }
1824
1825    impl ::std::fmt::Display for CoreTransferredResponseTransferredItemWhat {
1826        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1827            match *self {
1828                Self::Transferring => f.write_str("transferring"),
1829                Self::Deleting => f.write_str("deleting"),
1830                Self::Checking => f.write_str("checking"),
1831                Self::Importing => f.write_str("importing"),
1832                Self::Hashing => f.write_str("hashing"),
1833                Self::Merging => f.write_str("merging"),
1834                Self::Listing => f.write_str("listing"),
1835                Self::Moving => f.write_str("moving"),
1836                Self::Renaming => f.write_str("renaming"),
1837            }
1838        }
1839    }
1840
1841    impl ::std::str::FromStr for CoreTransferredResponseTransferredItemWhat {
1842        type Err = self::error::ConversionError;
1843        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1844            match value {
1845                "transferring" => Ok(Self::Transferring),
1846                "deleting" => Ok(Self::Deleting),
1847                "checking" => Ok(Self::Checking),
1848                "importing" => Ok(Self::Importing),
1849                "hashing" => Ok(Self::Hashing),
1850                "merging" => Ok(Self::Merging),
1851                "listing" => Ok(Self::Listing),
1852                "moving" => Ok(Self::Moving),
1853                "renaming" => Ok(Self::Renaming),
1854                _ => Err("invalid value".into()),
1855            }
1856        }
1857    }
1858
1859    impl ::std::convert::TryFrom<&str> for CoreTransferredResponseTransferredItemWhat {
1860        type Error = self::error::ConversionError;
1861        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
1862            value.parse()
1863        }
1864    }
1865
1866    impl ::std::convert::TryFrom<&::std::string::String>
1867        for CoreTransferredResponseTransferredItemWhat
1868    {
1869        type Error = self::error::ConversionError;
1870        fn try_from(
1871            value: &::std::string::String,
1872        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1873            value.parse()
1874        }
1875    }
1876
1877    impl ::std::convert::TryFrom<::std::string::String> for CoreTransferredResponseTransferredItemWhat {
1878        type Error = self::error::ConversionError;
1879        fn try_from(
1880            value: ::std::string::String,
1881        ) -> ::std::result::Result<Self, self::error::ConversionError> {
1882            value.parse()
1883        }
1884    }
1885
1886    ///`CoreVersionResponse`
1887    ///
1888    /// <details><summary>JSON schema</summary>
1889    ///
1890    /// ```json
1891    ///{
1892    ///  "type": "object",
1893    ///  "required": [
1894    ///    "arch",
1895    ///    "decomposed",
1896    ///    "goTags",
1897    ///    "goVersion",
1898    ///    "isBeta",
1899    ///    "isGit",
1900    ///    "linking",
1901    ///    "os",
1902    ///    "version"
1903    ///  ],
1904    ///  "properties": {
1905    ///    "arch": {
1906    ///      "description": "CPU architecture (e.g. amd64, arm64).",
1907    ///      "type": "string"
1908    ///    },
1909    ///    "decomposed": {
1910    ///      "description": "Version number broken into components.",
1911    ///      "type": "array",
1912    ///      "items": {
1913    ///        "type": "number"
1914    ///      }
1915    ///    },
1916    ///    "goTags": {
1917    ///      "description": "Space separated Go build tags, if any.",
1918    ///      "type": "string"
1919    ///    },
1920    ///    "goVersion": {
1921    ///      "description": "Go toolchain version used to build rclone.",
1922    ///      "type": "string"
1923    ///    },
1924    ///    "isBeta": {
1925    ///      "description": "Indicates whether this build is a beta version.",
1926    ///      "type": "boolean"
1927    ///    },
1928    ///    "isGit": {
1929    ///      "description": "True when built directly from a git checkout.",
1930    ///      "type": "boolean"
1931    ///    },
1932    ///    "linking": {
1933    ///      "description": "Linking mode for the binary (static or dynamic).",
1934    ///      "type": "string"
1935    ///    },
1936    ///    "os": {
1937    ///      "description": "Operating system rclone is running on (e.g. linux,
1938    /// darwin).",
1939    ///      "type": "string"
1940    ///    },
1941    ///    "osArch": {
1942    ///      "description": "CPU architecture in use (e.g. arm64 (ARMv8
1943    /// compatible)).",
1944    ///      "type": "string"
1945    ///    },
1946    ///    "osKernel": {
1947    ///      "description": "OS Kernel version (e.g. 6.8.0-86-generic
1948    /// (x86_64)).",
1949    ///      "type": "string"
1950    ///    },
1951    ///    "osVersion": {
1952    ///      "description": "OS Version (e.g. ubuntu 24.04 (64 bit)).",
1953    ///      "type": "string"
1954    ///    },
1955    ///    "version": {
1956    ///      "description": "Full semantic version string (e.g. 1.67.0).",
1957    ///      "type": "string"
1958    ///    }
1959    ///  }
1960    ///}
1961    /// ```
1962    /// </details>
1963    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1964    pub struct CoreVersionResponse {
1965        ///CPU architecture (e.g. amd64, arm64).
1966        pub arch: ::std::string::String,
1967        ///Version number broken into components.
1968        pub decomposed: ::std::vec::Vec<f64>,
1969        ///Space separated Go build tags, if any.
1970        #[serde(rename = "goTags")]
1971        pub go_tags: ::std::string::String,
1972        ///Go toolchain version used to build rclone.
1973        #[serde(rename = "goVersion")]
1974        pub go_version: ::std::string::String,
1975        ///Indicates whether this build is a beta version.
1976        #[serde(rename = "isBeta")]
1977        pub is_beta: bool,
1978        ///True when built directly from a git checkout.
1979        #[serde(rename = "isGit")]
1980        pub is_git: bool,
1981        ///Linking mode for the binary (static or dynamic).
1982        pub linking: ::std::string::String,
1983        ///Operating system rclone is running on (e.g. linux, darwin).
1984        pub os: ::std::string::String,
1985        ///CPU architecture in use (e.g. arm64 (ARMv8 compatible)).
1986        #[serde(
1987            rename = "osArch",
1988            default,
1989            skip_serializing_if = "::std::option::Option::is_none"
1990        )]
1991        pub os_arch: ::std::option::Option<::std::string::String>,
1992        ///OS Kernel version (e.g. 6.8.0-86-generic (x86_64)).
1993        #[serde(
1994            rename = "osKernel",
1995            default,
1996            skip_serializing_if = "::std::option::Option::is_none"
1997        )]
1998        pub os_kernel: ::std::option::Option<::std::string::String>,
1999        ///OS Version (e.g. ubuntu 24.04 (64 bit)).
2000        #[serde(
2001            rename = "osVersion",
2002            default,
2003            skip_serializing_if = "::std::option::Option::is_none"
2004        )]
2005        pub os_version: ::std::option::Option<::std::string::String>,
2006        ///Full semantic version string (e.g. 1.67.0).
2007        pub version: ::std::string::String,
2008    }
2009
2010    impl ::std::convert::From<&CoreVersionResponse> for CoreVersionResponse {
2011        fn from(value: &CoreVersionResponse) -> Self {
2012            value.clone()
2013        }
2014    }
2015
2016    ///`DebugSetGcPercentResponse`
2017    ///
2018    /// <details><summary>JSON schema</summary>
2019    ///
2020    /// ```json
2021    ///{
2022    ///  "type": "object",
2023    ///  "required": [
2024    ///    "existing-gc-percent"
2025    ///  ],
2026    ///  "properties": {
2027    ///    "existing-gc-percent": {
2028    ///      "type": "integer"
2029    ///    }
2030    ///  }
2031    ///}
2032    /// ```
2033    /// </details>
2034    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2035    pub struct DebugSetGcPercentResponse {
2036        #[serde(rename = "existing-gc-percent")]
2037        pub existing_gc_percent: i64,
2038    }
2039
2040    impl ::std::convert::From<&DebugSetGcPercentResponse> for DebugSetGcPercentResponse {
2041        fn from(value: &DebugSetGcPercentResponse) -> Self {
2042            value.clone()
2043        }
2044    }
2045
2046    ///`DebugSetMutexProfileFractionResponse`
2047    ///
2048    /// <details><summary>JSON schema</summary>
2049    ///
2050    /// ```json
2051    ///{
2052    ///  "type": "object",
2053    ///  "required": [
2054    ///    "previousRate"
2055    ///  ],
2056    ///  "properties": {
2057    ///    "previousRate": {
2058    ///      "type": "integer"
2059    ///    }
2060    ///  }
2061    ///}
2062    /// ```
2063    /// </details>
2064    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2065    pub struct DebugSetMutexProfileFractionResponse {
2066        #[serde(rename = "previousRate")]
2067        pub previous_rate: i64,
2068    }
2069
2070    impl ::std::convert::From<&DebugSetMutexProfileFractionResponse>
2071        for DebugSetMutexProfileFractionResponse
2072    {
2073        fn from(value: &DebugSetMutexProfileFractionResponse) -> Self {
2074            value.clone()
2075        }
2076    }
2077
2078    ///`DebugSetSoftMemoryLimitResponse`
2079    ///
2080    /// <details><summary>JSON schema</summary>
2081    ///
2082    /// ```json
2083    ///{
2084    ///  "type": "object",
2085    ///  "required": [
2086    ///    "existing-mem-limit"
2087    ///  ],
2088    ///  "properties": {
2089    ///    "existing-mem-limit": {
2090    ///      "type": "integer"
2091    ///    }
2092    ///  }
2093    ///}
2094    /// ```
2095    /// </details>
2096    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2097    pub struct DebugSetSoftMemoryLimitResponse {
2098        #[serde(rename = "existing-mem-limit")]
2099        pub existing_mem_limit: i64,
2100    }
2101
2102    impl ::std::convert::From<&DebugSetSoftMemoryLimitResponse> for DebugSetSoftMemoryLimitResponse {
2103        fn from(value: &DebugSetSoftMemoryLimitResponse) -> Self {
2104            value.clone()
2105        }
2106    }
2107
2108    ///`FscacheEntriesResponse`
2109    ///
2110    /// <details><summary>JSON schema</summary>
2111    ///
2112    /// ```json
2113    ///{
2114    ///  "type": "object",
2115    ///  "required": [
2116    ///    "entries"
2117    ///  ],
2118    ///  "properties": {
2119    ///    "entries": {
2120    ///      "type": "integer"
2121    ///    }
2122    ///  }
2123    ///}
2124    /// ```
2125    /// </details>
2126    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2127    pub struct FscacheEntriesResponse {
2128        pub entries: i64,
2129    }
2130
2131    impl ::std::convert::From<&FscacheEntriesResponse> for FscacheEntriesResponse {
2132        fn from(value: &FscacheEntriesResponse) -> Self {
2133            value.clone()
2134        }
2135    }
2136
2137    ///`JobBatchInputsItem`
2138    ///
2139    /// <details><summary>JSON schema</summary>
2140    ///
2141    /// ```json
2142    ///{
2143    ///  "type": "object",
2144    ///  "required": [
2145    ///    "_path"
2146    ///  ],
2147    ///  "properties": {
2148    ///    "_path": {
2149    ///      "description": "rc/path",
2150    ///      "type": "string"
2151    ///    }
2152    ///  },
2153    ///  "additionalProperties": true
2154    ///}
2155    /// ```
2156    /// </details>
2157    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2158    pub struct JobBatchInputsItem {
2159        ///rc/path
2160        #[serde(rename = "_path")]
2161        pub path: ::std::string::String,
2162    }
2163
2164    impl ::std::convert::From<&JobBatchInputsItem> for JobBatchInputsItem {
2165        fn from(value: &JobBatchInputsItem) -> Self {
2166            value.clone()
2167        }
2168    }
2169
2170    ///`JobBatchRequest`
2171    ///
2172    /// <details><summary>JSON schema</summary>
2173    ///
2174    /// ```json
2175    ///{
2176    ///  "type": "object",
2177    ///  "properties": {
2178    ///    "_async": {
2179    ///      "description": "Run the command asynchronously. Returns a job id
2180    /// immediately.",
2181    ///      "type": "boolean"
2182    ///    },
2183    ///    "concurrency": {
2184    ///      "description": "Do this many commands concurrently. Defaults to
2185    /// --transfers if not set.",
2186    ///      "type": "integer"
2187    ///    },
2188    ///    "inputs": {
2189    ///      "description": "List of inputs to the commands with an extra _path
2190    /// parameter.",
2191    ///      "type": "array",
2192    ///      "items": {
2193    ///        "type": "object",
2194    ///        "required": [
2195    ///          "_path"
2196    ///        ],
2197    ///        "properties": {
2198    ///          "_path": {
2199    ///            "description": "rc/path",
2200    ///            "type": "string"
2201    ///          }
2202    ///        },
2203    ///        "additionalProperties": true
2204    ///      }
2205    ///    }
2206    ///  }
2207    ///}
2208    /// ```
2209    /// </details>
2210    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2211    pub struct JobBatchRequest {
2212        ///Run the command asynchronously. Returns a job id immediately.
2213        #[serde(
2214            rename = "_async",
2215            default,
2216            skip_serializing_if = "::std::option::Option::is_none"
2217        )]
2218        pub async_: ::std::option::Option<bool>,
2219        ///Do this many commands concurrently. Defaults to --transfers if not
2220        /// set.
2221        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2222        pub concurrency: ::std::option::Option<i64>,
2223        ///List of inputs to the commands with an extra _path parameter.
2224        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2225        pub inputs: ::std::vec::Vec<JobBatchRequestInputsItem>,
2226    }
2227
2228    impl ::std::convert::From<&JobBatchRequest> for JobBatchRequest {
2229        fn from(value: &JobBatchRequest) -> Self {
2230            value.clone()
2231        }
2232    }
2233
2234    impl ::std::default::Default for JobBatchRequest {
2235        fn default() -> Self {
2236            Self {
2237                async_: Default::default(),
2238                concurrency: Default::default(),
2239                inputs: Default::default(),
2240            }
2241        }
2242    }
2243
2244    ///`JobBatchRequestInputsItem`
2245    ///
2246    /// <details><summary>JSON schema</summary>
2247    ///
2248    /// ```json
2249    ///{
2250    ///  "type": "object",
2251    ///  "required": [
2252    ///    "_path"
2253    ///  ],
2254    ///  "properties": {
2255    ///    "_path": {
2256    ///      "description": "rc/path",
2257    ///      "type": "string"
2258    ///    }
2259    ///  },
2260    ///  "additionalProperties": true
2261    ///}
2262    /// ```
2263    /// </details>
2264    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2265    pub struct JobBatchRequestInputsItem {
2266        ///rc/path
2267        #[serde(rename = "_path")]
2268        pub path: ::std::string::String,
2269    }
2270
2271    impl ::std::convert::From<&JobBatchRequestInputsItem> for JobBatchRequestInputsItem {
2272        fn from(value: &JobBatchRequestInputsItem) -> Self {
2273            value.clone()
2274        }
2275    }
2276
2277    ///`JobBatchResponse`
2278    ///
2279    /// <details><summary>JSON schema</summary>
2280    ///
2281    /// ```json
2282    ///{
2283    ///  "type": "object",
2284    ///  "required": [
2285    ///    "executeId",
2286    ///    "jobid"
2287    ///  ],
2288    ///  "properties": {
2289    ///    "executeId": {
2290    ///      "description": "Identifier for this rclone process.",
2291    ///      "type": "string"
2292    ///    },
2293    ///    "jobid": {
2294    ///      "description": "ID of the async job.",
2295    ///      "type": "integer"
2296    ///    }
2297    ///  }
2298    ///}
2299    /// ```
2300    /// </details>
2301    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2302    pub struct JobBatchResponse {
2303        ///Identifier for this rclone process.
2304        #[serde(rename = "executeId")]
2305        pub execute_id: ::std::string::String,
2306        ///ID of the async job.
2307        pub jobid: i64,
2308    }
2309
2310    impl ::std::convert::From<&JobBatchResponse> for JobBatchResponse {
2311        fn from(value: &JobBatchResponse) -> Self {
2312            value.clone()
2313        }
2314    }
2315
2316    ///`JobListResponse`
2317    ///
2318    /// <details><summary>JSON schema</summary>
2319    ///
2320    /// ```json
2321    ///{
2322    ///  "type": "object",
2323    ///  "required": [
2324    ///    "executeId",
2325    ///    "finishedIds",
2326    ///    "jobids",
2327    ///    "runningIds"
2328    ///  ],
2329    ///  "properties": {
2330    ///    "executeId": {
2331    ///      "description": "Identifier for this rclone process.",
2332    ///      "type": "string"
2333    ///    },
2334    ///    "finishedIds": {
2335    ///      "description": "Array of integer job ids that are finished.",
2336    ///      "type": "array",
2337    ///      "items": {
2338    ///        "type": "integer"
2339    ///      }
2340    ///    },
2341    ///    "jobids": {
2342    ///      "description": "Job IDs suitable for use with `job/status` and
2343    /// `job/stop`.",
2344    ///      "type": "array",
2345    ///      "items": {
2346    ///        "type": "number"
2347    ///      }
2348    ///    },
2349    ///    "runningIds": {
2350    ///      "description": "Array of integer job ids that are running.",
2351    ///      "type": "array",
2352    ///      "items": {
2353    ///        "type": "integer"
2354    ///      }
2355    ///    }
2356    ///  }
2357    ///}
2358    /// ```
2359    /// </details>
2360    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2361    pub struct JobListResponse {
2362        ///Identifier for this rclone process.
2363        #[serde(rename = "executeId")]
2364        pub execute_id: ::std::string::String,
2365        ///Array of integer job ids that are finished.
2366        #[serde(rename = "finishedIds")]
2367        pub finished_ids: ::std::vec::Vec<i64>,
2368        ///Job IDs suitable for use with `job/status` and `job/stop`.
2369        pub jobids: ::std::vec::Vec<f64>,
2370        ///Array of integer job ids that are running.
2371        #[serde(rename = "runningIds")]
2372        pub running_ids: ::std::vec::Vec<i64>,
2373    }
2374
2375    impl ::std::convert::From<&JobListResponse> for JobListResponse {
2376        fn from(value: &JobListResponse) -> Self {
2377            value.clone()
2378        }
2379    }
2380
2381    ///`JobStatusResponse`
2382    ///
2383    /// <details><summary>JSON schema</summary>
2384    ///
2385    /// ```json
2386    ///{
2387    ///  "type": "object",
2388    ///  "required": [
2389    ///    "duration",
2390    ///    "endTime",
2391    ///    "error",
2392    ///    "finished",
2393    ///    "id",
2394    ///    "startTime",
2395    ///    "success"
2396    ///  ],
2397    ///  "properties": {
2398    ///    "duration": {
2399    ///      "description": "Execution time in seconds.",
2400    ///      "type": "number"
2401    ///    },
2402    ///    "endTime": {
2403    ///      "description": "Timestamp when the job finished. (e.g.
2404    /// '2025-12-26T18:50:20.528746884+01:00')",
2405    ///      "type": "string"
2406    ///    },
2407    ///    "error": {
2408    ///      "description": "Error message, or empty string on success.",
2409    ///      "type": "string"
2410    ///    },
2411    ///    "finished": {
2412    ///      "description": "True once the job has completed.",
2413    ///      "type": "boolean"
2414    ///    },
2415    ///    "id": {
2416    ///      "description": "Job identifier.",
2417    ///      "type": "number"
2418    ///    },
2419    ///    "output": {
2420    ///      "description": "Synchronous-style output payload when available."
2421    ///    },
2422    ///    "progress": {
2423    ///      "description": "Progress measurements supplied by the underlying
2424    /// command."
2425    ///    },
2426    ///    "startTime": {
2427    ///      "description": "Timestamp when the job started. (e.g.
2428    /// '2025-12-24T18:50:20.5281314+01:00')",
2429    ///      "type": "string"
2430    ///    },
2431    ///    "success": {
2432    ///      "description": "True if the job completed successfully.",
2433    ///      "type": "boolean"
2434    ///    }
2435    ///  }
2436    ///}
2437    /// ```
2438    /// </details>
2439    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2440    pub struct JobStatusResponse {
2441        pub duration: f64,
2442        ///Timestamp when the job finished. (e.g.
2443        /// '2025-12-26T18:50:20.528746884+01:00')
2444        #[serde(rename = "endTime")]
2445        pub end_time: ::std::string::String,
2446        ///Error message, or empty string on success.
2447        pub error: ::std::string::String,
2448        ///True once the job has completed.
2449        pub finished: bool,
2450        pub id: f64,
2451        ///Synchronous-style output payload when available.
2452        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2453        pub output: ::std::option::Option<::serde_json::Value>,
2454        ///Progress measurements supplied by the underlying command.
2455        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2456        pub progress: ::std::option::Option<::serde_json::Value>,
2457        ///Timestamp when the job started. (e.g.
2458        /// '2025-12-24T18:50:20.5281314+01:00')
2459        #[serde(rename = "startTime")]
2460        pub start_time: ::std::string::String,
2461        ///True if the job completed successfully.
2462        pub success: bool,
2463    }
2464
2465    impl ::std::convert::From<&JobStatusResponse> for JobStatusResponse {
2466        fn from(value: &JobStatusResponse) -> Self {
2467            value.clone()
2468        }
2469    }
2470
2471    ///`MountListmountsResponse`
2472    ///
2473    /// <details><summary>JSON schema</summary>
2474    ///
2475    /// ```json
2476    ///{
2477    ///  "type": "object",
2478    ///  "required": [
2479    ///    "mountPoints"
2480    ///  ],
2481    ///  "properties": {
2482    ///    "mountPoints": {
2483    ///      "type": "array",
2484    ///      "items": {
2485    ///        "type": "object",
2486    ///        "required": [
2487    ///          "Fs",
2488    ///          "MountPoint",
2489    ///          "MountedOn"
2490    ///        ],
2491    ///        "properties": {
2492    ///          "Fs": {
2493    ///            "type": "string"
2494    ///          },
2495    ///          "MountPoint": {
2496    ///            "type": "string"
2497    ///          },
2498    ///          "MountedOn": {
2499    ///            "type": "string",
2500    ///            "format": "date-time"
2501    ///          }
2502    ///        },
2503    ///        "additionalProperties": false
2504    ///      }
2505    ///    }
2506    ///  }
2507    ///}
2508    /// ```
2509    /// </details>
2510    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2511    pub struct MountListmountsResponse {
2512        #[serde(rename = "mountPoints")]
2513        pub mount_points: ::std::vec::Vec<MountListmountsResponseMountPointsItem>,
2514    }
2515
2516    impl ::std::convert::From<&MountListmountsResponse> for MountListmountsResponse {
2517        fn from(value: &MountListmountsResponse) -> Self {
2518            value.clone()
2519        }
2520    }
2521
2522    ///`MountListmountsResponseMountPointsItem`
2523    ///
2524    /// <details><summary>JSON schema</summary>
2525    ///
2526    /// ```json
2527    ///{
2528    ///  "type": "object",
2529    ///  "required": [
2530    ///    "Fs",
2531    ///    "MountPoint",
2532    ///    "MountedOn"
2533    ///  ],
2534    ///  "properties": {
2535    ///    "Fs": {
2536    ///      "type": "string"
2537    ///    },
2538    ///    "MountPoint": {
2539    ///      "type": "string"
2540    ///    },
2541    ///    "MountedOn": {
2542    ///      "type": "string",
2543    ///      "format": "date-time"
2544    ///    }
2545    ///  },
2546    ///  "additionalProperties": false
2547    ///}
2548    /// ```
2549    /// </details>
2550    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2551    #[serde(deny_unknown_fields)]
2552    pub struct MountListmountsResponseMountPointsItem {
2553        #[serde(rename = "Fs")]
2554        pub fs: ::std::string::String,
2555        #[serde(rename = "MountPoint")]
2556        pub mount_point: ::std::string::String,
2557        #[serde(rename = "MountedOn")]
2558        pub mounted_on: ::chrono::DateTime<::chrono::offset::Utc>,
2559    }
2560
2561    impl ::std::convert::From<&MountListmountsResponseMountPointsItem>
2562        for MountListmountsResponseMountPointsItem
2563    {
2564        fn from(value: &MountListmountsResponseMountPointsItem) -> Self {
2565            value.clone()
2566        }
2567    }
2568
2569    ///`MountTypesResponse`
2570    ///
2571    /// <details><summary>JSON schema</summary>
2572    ///
2573    /// ```json
2574    ///{
2575    ///  "type": "object",
2576    ///  "required": [
2577    ///    "mountTypes"
2578    ///  ],
2579    ///  "properties": {
2580    ///    "mountTypes": {
2581    ///      "type": "array",
2582    ///      "items": {
2583    ///        "type": "string"
2584    ///      }
2585    ///    }
2586    ///  }
2587    ///}
2588    /// ```
2589    /// </details>
2590    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2591    pub struct MountTypesResponse {
2592        #[serde(rename = "mountTypes")]
2593        pub mount_types: ::std::vec::Vec<::std::string::String>,
2594    }
2595
2596    impl ::std::convert::From<&MountTypesResponse> for MountTypesResponse {
2597        fn from(value: &MountTypesResponse) -> Self {
2598            value.clone()
2599        }
2600    }
2601
2602    ///`OperationsAboutResponse`
2603    ///
2604    /// <details><summary>JSON schema</summary>
2605    ///
2606    /// ```json
2607    ///{
2608    ///  "type": "object",
2609    ///  "required": [
2610    ///    "free",
2611    ///    "total",
2612    ///    "used"
2613    ///  ],
2614    ///  "properties": {
2615    ///    "free": {
2616    ///      "type": "number"
2617    ///    },
2618    ///    "objects": {
2619    ///      "type": "number"
2620    ///    },
2621    ///    "other": {
2622    ///      "type": "number"
2623    ///    },
2624    ///    "total": {
2625    ///      "type": "number"
2626    ///    },
2627    ///    "trashed": {
2628    ///      "type": "number"
2629    ///    },
2630    ///    "used": {
2631    ///      "type": "number"
2632    ///    }
2633    ///  }
2634    ///}
2635    /// ```
2636    /// </details>
2637    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2638    pub struct OperationsAboutResponse {
2639        pub free: f64,
2640        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2641        pub objects: ::std::option::Option<f64>,
2642        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2643        pub other: ::std::option::Option<f64>,
2644        pub total: f64,
2645        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2646        pub trashed: ::std::option::Option<f64>,
2647        pub used: f64,
2648    }
2649
2650    impl ::std::convert::From<&OperationsAboutResponse> for OperationsAboutResponse {
2651        fn from(value: &OperationsAboutResponse) -> Self {
2652            value.clone()
2653        }
2654    }
2655
2656    ///`OperationsCheckResponse`
2657    ///
2658    /// <details><summary>JSON schema</summary>
2659    ///
2660    /// ```json
2661    ///{
2662    ///  "type": "object",
2663    ///  "required": [
2664    ///    "status",
2665    ///    "success"
2666    ///  ],
2667    ///  "properties": {
2668    ///    "combined": {
2669    ///      "description": "Combined summary lines when `combined=true` is
2670    /// requested.",
2671    ///      "type": "array",
2672    ///      "items": {
2673    ///        "type": "string"
2674    ///      }
2675    ///    },
2676    ///    "differ": {
2677    ///      "description": "Files that differed between source and
2678    /// destination.",
2679    ///      "type": "array",
2680    ///      "items": {
2681    ///        "type": "string"
2682    ///      }
2683    ///    },
2684    ///    "error": {
2685    ///      "description": "Entries that produced errors during the check.",
2686    ///      "type": "array",
2687    ///      "items": {
2688    ///        "type": "string"
2689    ///      }
2690    ///    },
2691    ///    "hashType": {
2692    ///      "description": "Hash algorithm used for comparisons when
2693    /// applicable.",
2694    ///      "type": "string"
2695    ///    },
2696    ///    "match": {
2697    ///      "description": "Files that matched on both sides.",
2698    ///      "type": "array",
2699    ///      "items": {
2700    ///        "type": "string"
2701    ///      }
2702    ///    },
2703    ///    "missingOnDst": {
2704    ///      "description": "Files present on the source but missing from the
2705    /// destination.",
2706    ///      "type": "array",
2707    ///      "items": {
2708    ///        "type": "string"
2709    ///      }
2710    ///    },
2711    ///    "missingOnSrc": {
2712    ///      "description": "Files present on the destination but missing from
2713    /// the source.",
2714    ///      "type": "array",
2715    ///      "items": {
2716    ///        "type": "string"
2717    ///      }
2718    ///    },
2719    ///    "status": {
2720    ///      "description": "Human readable status string.",
2721    ///      "type": "string"
2722    ///    },
2723    ///    "success": {
2724    ///      "description": "True when the check completes without differences
2725    /// or errors.",
2726    ///      "type": "boolean"
2727    ///    }
2728    ///  }
2729    ///}
2730    /// ```
2731    /// </details>
2732    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2733    pub struct OperationsCheckResponse {
2734        ///Combined summary lines when `combined=true` is requested.
2735        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2736        pub combined: ::std::vec::Vec<::std::string::String>,
2737        ///Files that differed between source and destination.
2738        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2739        pub differ: ::std::vec::Vec<::std::string::String>,
2740        ///Entries that produced errors during the check.
2741        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2742        pub error: ::std::vec::Vec<::std::string::String>,
2743        ///Hash algorithm used for comparisons when applicable.
2744        #[serde(
2745            rename = "hashType",
2746            default,
2747            skip_serializing_if = "::std::option::Option::is_none"
2748        )]
2749        pub hash_type: ::std::option::Option<::std::string::String>,
2750        ///Files that matched on both sides.
2751        #[serde(
2752            rename = "match",
2753            default,
2754            skip_serializing_if = "::std::vec::Vec::is_empty"
2755        )]
2756        pub match_: ::std::vec::Vec<::std::string::String>,
2757        ///Files present on the source but missing from the destination.
2758        #[serde(
2759            rename = "missingOnDst",
2760            default,
2761            skip_serializing_if = "::std::vec::Vec::is_empty"
2762        )]
2763        pub missing_on_dst: ::std::vec::Vec<::std::string::String>,
2764        ///Files present on the destination but missing from the source.
2765        #[serde(
2766            rename = "missingOnSrc",
2767            default,
2768            skip_serializing_if = "::std::vec::Vec::is_empty"
2769        )]
2770        pub missing_on_src: ::std::vec::Vec<::std::string::String>,
2771        ///Human readable status string.
2772        pub status: ::std::string::String,
2773        ///True when the check completes without differences or errors.
2774        pub success: bool,
2775    }
2776
2777    impl ::std::convert::From<&OperationsCheckResponse> for OperationsCheckResponse {
2778        fn from(value: &OperationsCheckResponse) -> Self {
2779            value.clone()
2780        }
2781    }
2782
2783    ///`OperationsFsinfoResponse`
2784    ///
2785    /// <details><summary>JSON schema</summary>
2786    ///
2787    /// ```json
2788    ///{
2789    ///  "type": "object",
2790    ///  "required": [
2791    ///    "Features",
2792    ///    "Hashes",
2793    ///    "Name",
2794    ///    "Precision",
2795    ///    "Root",
2796    ///    "String"
2797    ///  ],
2798    ///  "properties": {
2799    ///    "Features": {
2800    ///      "type": "object",
2801    ///      "additionalProperties": {
2802    ///        "type": "boolean"
2803    ///      }
2804    ///    },
2805    ///    "Hashes": {
2806    ///      "type": "array",
2807    ///      "items": {
2808    ///        "type": "string"
2809    ///      }
2810    ///    },
2811    ///    "MetadataInfo": {
2812    ///      "type": [
2813    ///        "object",
2814    ///        "null"
2815    ///      ],
2816    ///      "additionalProperties": true
2817    ///    },
2818    ///    "Name": {
2819    ///      "type": "string"
2820    ///    },
2821    ///    "Precision": {
2822    ///      "type": "number"
2823    ///    },
2824    ///    "Root": {
2825    ///      "type": "string"
2826    ///    },
2827    ///    "String": {
2828    ///      "type": "string"
2829    ///    }
2830    ///  }
2831    ///}
2832    /// ```
2833    /// </details>
2834    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2835    pub struct OperationsFsinfoResponse {
2836        #[serde(rename = "Features")]
2837        pub features: ::std::collections::HashMap<::std::string::String, bool>,
2838        #[serde(rename = "Hashes")]
2839        pub hashes: ::std::vec::Vec<::std::string::String>,
2840        #[serde(
2841            rename = "MetadataInfo",
2842            default,
2843            skip_serializing_if = "::std::option::Option::is_none"
2844        )]
2845        pub metadata_info:
2846            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
2847        #[serde(rename = "Name")]
2848        pub name: ::std::string::String,
2849        #[serde(rename = "Precision")]
2850        pub precision: f64,
2851        #[serde(rename = "Root")]
2852        pub root: ::std::string::String,
2853        #[serde(rename = "String")]
2854        pub string: ::std::string::String,
2855    }
2856
2857    impl ::std::convert::From<&OperationsFsinfoResponse> for OperationsFsinfoResponse {
2858        fn from(value: &OperationsFsinfoResponse) -> Self {
2859            value.clone()
2860        }
2861    }
2862
2863    ///`OperationsHashsumResponse`
2864    ///
2865    /// <details><summary>JSON schema</summary>
2866    ///
2867    /// ```json
2868    ///{
2869    ///  "type": "object",
2870    ///  "required": [
2871    ///    "hashType",
2872    ///    "hashsum"
2873    ///  ],
2874    ///  "properties": {
2875    ///    "hashType": {
2876    ///      "type": "string"
2877    ///    },
2878    ///    "hashsum": {
2879    ///      "type": "array",
2880    ///      "items": {
2881    ///        "type": "string"
2882    ///      }
2883    ///    }
2884    ///  }
2885    ///}
2886    /// ```
2887    /// </details>
2888    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2889    pub struct OperationsHashsumResponse {
2890        #[serde(rename = "hashType")]
2891        pub hash_type: ::std::string::String,
2892        pub hashsum: ::std::vec::Vec<::std::string::String>,
2893    }
2894
2895    impl ::std::convert::From<&OperationsHashsumResponse> for OperationsHashsumResponse {
2896        fn from(value: &OperationsHashsumResponse) -> Self {
2897            value.clone()
2898        }
2899    }
2900
2901    ///`OperationsHashsumfileResponse`
2902    ///
2903    /// <details><summary>JSON schema</summary>
2904    ///
2905    /// ```json
2906    ///{
2907    ///  "type": "object",
2908    ///  "required": [
2909    ///    "hash",
2910    ///    "hashType"
2911    ///  ],
2912    ///  "properties": {
2913    ///    "hash": {
2914    ///      "description": "The hash value of the file.",
2915    ///      "type": "string"
2916    ///    },
2917    ///    "hashType": {
2918    ///      "description": "The hash algorithm that was used.",
2919    ///      "type": "string"
2920    ///    }
2921    ///  }
2922    ///}
2923    /// ```
2924    /// </details>
2925    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2926    pub struct OperationsHashsumfileResponse {
2927        ///The hash value of the file.
2928        pub hash: ::std::string::String,
2929        ///The hash algorithm that was used.
2930        #[serde(rename = "hashType")]
2931        pub hash_type: ::std::string::String,
2932    }
2933
2934    impl ::std::convert::From<&OperationsHashsumfileResponse> for OperationsHashsumfileResponse {
2935        fn from(value: &OperationsHashsumfileResponse) -> Self {
2936            value.clone()
2937        }
2938    }
2939
2940    ///`OperationsListResponse`
2941    ///
2942    /// <details><summary>JSON schema</summary>
2943    ///
2944    /// ```json
2945    ///{
2946    ///  "type": "object",
2947    ///  "required": [
2948    ///    "list"
2949    ///  ],
2950    ///  "properties": {
2951    ///    "list": {
2952    ///      "description": "Array of entries equivalent to the items returned
2953    /// by `rclone lsjson`.",
2954    ///      "type": "array",
2955    ///      "items": {
2956    ///        "type": "object",
2957    ///        "required": [
2958    ///          "IsDir",
2959    ///          "Name",
2960    ///          "Path"
2961    ///        ],
2962    ///        "properties": {
2963    ///          "Encrypted": {
2964    ///            "description": "Encrypted entry name when using crypt
2965    /// remotes.",
2966    ///            "type": "string"
2967    ///          },
2968    ///          "EncryptedPath": {
2969    ///            "description": "Encrypted path when using crypt remotes.",
2970    ///            "type": "string"
2971    ///          },
2972    ///          "Hashes": {
2973    ///            "description": "Hash digests keyed by algorithm when
2974    /// requested.",
2975    ///            "type": "object",
2976    ///            "additionalProperties": {
2977    ///              "type": "string"
2978    ///            }
2979    ///          },
2980    ///          "ID": {
2981    ///            "description": "Backend-specific identifier when provided.",
2982    ///            "type": "string"
2983    ///          },
2984    ///          "IsBucket": {
2985    ///            "description": "True for bucket/root entries on bucket-based
2986    /// remotes.",
2987    ///            "type": "boolean"
2988    ///          },
2989    ///          "IsDir": {
2990    ///            "description": "True if the entry represents a directory.",
2991    ///            "type": "boolean"
2992    ///          },
2993    ///          "Metadata": {
2994    ///            "description": "Backend-provided metadata map.",
2995    ///            "type": "object",
2996    ///            "additionalProperties": {}
2997    ///          },
2998    ///          "MimeType": {
2999    ///            "description": "MIME type where available.",
3000    ///            "type": "string"
3001    ///          },
3002    ///          "ModTime": {
3003    ///            "description": "Modification timestamp in RFC3339 format.",
3004    ///            "type": "string"
3005    ///          },
3006    ///          "Name": {
3007    ///            "description": "Base name of the entry.",
3008    ///            "type": "string"
3009    ///          },
3010    ///          "OrigID": {
3011    ///            "description": "Original backend identifier when recorded.",
3012    ///            "type": "string"
3013    ///          },
3014    ///          "Path": {
3015    ///            "description": "Path relative to the requested remote root.",
3016    ///            "type": "string"
3017    ///          },
3018    ///          "Size": {
3019    ///            "description": "Object size in bytes.",
3020    ///            "type": "number"
3021    ///          },
3022    ///          "Tier": {
3023    ///            "description": "Storage class or tier, if supplied by the
3024    /// backend.",
3025    ///            "type": "string"
3026    ///          }
3027    ///        }
3028    ///      }
3029    ///    }
3030    ///  }
3031    ///}
3032    /// ```
3033    /// </details>
3034    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3035    pub struct OperationsListResponse {
3036        ///Array of entries equivalent to the items returned by `rclone
3037        /// lsjson`.
3038        pub list: ::std::vec::Vec<OperationsListResponseListItem>,
3039    }
3040
3041    impl ::std::convert::From<&OperationsListResponse> for OperationsListResponse {
3042        fn from(value: &OperationsListResponse) -> Self {
3043            value.clone()
3044        }
3045    }
3046
3047    ///`OperationsListResponseListItem`
3048    ///
3049    /// <details><summary>JSON schema</summary>
3050    ///
3051    /// ```json
3052    ///{
3053    ///  "type": "object",
3054    ///  "required": [
3055    ///    "IsDir",
3056    ///    "Name",
3057    ///    "Path"
3058    ///  ],
3059    ///  "properties": {
3060    ///    "Encrypted": {
3061    ///      "description": "Encrypted entry name when using crypt remotes.",
3062    ///      "type": "string"
3063    ///    },
3064    ///    "EncryptedPath": {
3065    ///      "description": "Encrypted path when using crypt remotes.",
3066    ///      "type": "string"
3067    ///    },
3068    ///    "Hashes": {
3069    ///      "description": "Hash digests keyed by algorithm when requested.",
3070    ///      "type": "object",
3071    ///      "additionalProperties": {
3072    ///        "type": "string"
3073    ///      }
3074    ///    },
3075    ///    "ID": {
3076    ///      "description": "Backend-specific identifier when provided.",
3077    ///      "type": "string"
3078    ///    },
3079    ///    "IsBucket": {
3080    ///      "description": "True for bucket/root entries on bucket-based
3081    /// remotes.",
3082    ///      "type": "boolean"
3083    ///    },
3084    ///    "IsDir": {
3085    ///      "description": "True if the entry represents a directory.",
3086    ///      "type": "boolean"
3087    ///    },
3088    ///    "Metadata": {
3089    ///      "description": "Backend-provided metadata map.",
3090    ///      "type": "object",
3091    ///      "additionalProperties": {}
3092    ///    },
3093    ///    "MimeType": {
3094    ///      "description": "MIME type where available.",
3095    ///      "type": "string"
3096    ///    },
3097    ///    "ModTime": {
3098    ///      "description": "Modification timestamp in RFC3339 format.",
3099    ///      "type": "string"
3100    ///    },
3101    ///    "Name": {
3102    ///      "description": "Base name of the entry.",
3103    ///      "type": "string"
3104    ///    },
3105    ///    "OrigID": {
3106    ///      "description": "Original backend identifier when recorded.",
3107    ///      "type": "string"
3108    ///    },
3109    ///    "Path": {
3110    ///      "description": "Path relative to the requested remote root.",
3111    ///      "type": "string"
3112    ///    },
3113    ///    "Size": {
3114    ///      "description": "Object size in bytes.",
3115    ///      "type": "number"
3116    ///    },
3117    ///    "Tier": {
3118    ///      "description": "Storage class or tier, if supplied by the
3119    /// backend.",
3120    ///      "type": "string"
3121    ///    }
3122    ///  }
3123    ///}
3124    /// ```
3125    /// </details>
3126    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3127    pub struct OperationsListResponseListItem {
3128        ///Encrypted entry name when using crypt remotes.
3129        #[serde(
3130            rename = "Encrypted",
3131            default,
3132            skip_serializing_if = "::std::option::Option::is_none"
3133        )]
3134        pub encrypted: ::std::option::Option<::std::string::String>,
3135        ///Encrypted path when using crypt remotes.
3136        #[serde(
3137            rename = "EncryptedPath",
3138            default,
3139            skip_serializing_if = "::std::option::Option::is_none"
3140        )]
3141        pub encrypted_path: ::std::option::Option<::std::string::String>,
3142        ///Hash digests keyed by algorithm when requested.
3143        #[serde(
3144            rename = "Hashes",
3145            default,
3146            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
3147        )]
3148        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3149        ///Backend-specific identifier when provided.
3150        #[serde(
3151            rename = "ID",
3152            default,
3153            skip_serializing_if = "::std::option::Option::is_none"
3154        )]
3155        pub id: ::std::option::Option<::std::string::String>,
3156        ///True for bucket/root entries on bucket-based remotes.
3157        #[serde(
3158            rename = "IsBucket",
3159            default,
3160            skip_serializing_if = "::std::option::Option::is_none"
3161        )]
3162        pub is_bucket: ::std::option::Option<bool>,
3163        ///True if the entry represents a directory.
3164        #[serde(rename = "IsDir")]
3165        pub is_dir: bool,
3166        ///Backend-provided metadata map.
3167        #[serde(
3168            rename = "Metadata",
3169            default,
3170            skip_serializing_if = "::serde_json::Map::is_empty"
3171        )]
3172        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3173        ///MIME type where available.
3174        #[serde(
3175            rename = "MimeType",
3176            default,
3177            skip_serializing_if = "::std::option::Option::is_none"
3178        )]
3179        pub mime_type: ::std::option::Option<::std::string::String>,
3180        ///Modification timestamp in RFC3339 format.
3181        #[serde(
3182            rename = "ModTime",
3183            default,
3184            skip_serializing_if = "::std::option::Option::is_none"
3185        )]
3186        pub mod_time: ::std::option::Option<::std::string::String>,
3187        ///Base name of the entry.
3188        #[serde(rename = "Name")]
3189        pub name: ::std::string::String,
3190        ///Original backend identifier when recorded.
3191        #[serde(
3192            rename = "OrigID",
3193            default,
3194            skip_serializing_if = "::std::option::Option::is_none"
3195        )]
3196        pub orig_id: ::std::option::Option<::std::string::String>,
3197        ///Path relative to the requested remote root.
3198        #[serde(rename = "Path")]
3199        pub path: ::std::string::String,
3200        #[serde(
3201            rename = "Size",
3202            default,
3203            skip_serializing_if = "::std::option::Option::is_none"
3204        )]
3205        pub size: ::std::option::Option<f64>,
3206        ///Storage class or tier, if supplied by the backend.
3207        #[serde(
3208            rename = "Tier",
3209            default,
3210            skip_serializing_if = "::std::option::Option::is_none"
3211        )]
3212        pub tier: ::std::option::Option<::std::string::String>,
3213    }
3214
3215    impl ::std::convert::From<&OperationsListResponseListItem> for OperationsListResponseListItem {
3216        fn from(value: &OperationsListResponseListItem) -> Self {
3217            value.clone()
3218        }
3219    }
3220
3221    ///`OperationsPubliclinkResponse`
3222    ///
3223    /// <details><summary>JSON schema</summary>
3224    ///
3225    /// ```json
3226    ///{
3227    ///  "type": "object",
3228    ///  "required": [
3229    ///    "url"
3230    ///  ],
3231    ///  "properties": {
3232    ///    "url": {
3233    ///      "type": "string",
3234    ///      "format": "uri"
3235    ///    }
3236    ///  }
3237    ///}
3238    /// ```
3239    /// </details>
3240    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3241    pub struct OperationsPubliclinkResponse {
3242        pub url: ::std::string::String,
3243    }
3244
3245    impl ::std::convert::From<&OperationsPubliclinkResponse> for OperationsPubliclinkResponse {
3246        fn from(value: &OperationsPubliclinkResponse) -> Self {
3247            value.clone()
3248        }
3249    }
3250
3251    ///`OperationsSizeResponse`
3252    ///
3253    /// <details><summary>JSON schema</summary>
3254    ///
3255    /// ```json
3256    ///{
3257    ///  "type": "object",
3258    ///  "required": [
3259    ///    "bytes",
3260    ///    "count",
3261    ///    "sizeless"
3262    ///  ],
3263    ///  "properties": {
3264    ///    "bytes": {
3265    ///      "type": "number"
3266    ///    },
3267    ///    "count": {
3268    ///      "type": "integer"
3269    ///    },
3270    ///    "sizeless": {
3271    ///      "type": "integer"
3272    ///    }
3273    ///  }
3274    ///}
3275    /// ```
3276    /// </details>
3277    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3278    pub struct OperationsSizeResponse {
3279        pub bytes: f64,
3280        pub count: i64,
3281        pub sizeless: i64,
3282    }
3283
3284    impl ::std::convert::From<&OperationsSizeResponse> for OperationsSizeResponse {
3285        fn from(value: &OperationsSizeResponse) -> Self {
3286            value.clone()
3287        }
3288    }
3289
3290    ///`OperationsStatResponse`
3291    ///
3292    /// <details><summary>JSON schema</summary>
3293    ///
3294    /// ```json
3295    ///{
3296    ///  "type": "object",
3297    ///  "required": [
3298    ///    "item"
3299    ///  ],
3300    ///  "properties": {
3301    ///    "item": {
3302    ///      "type": [
3303    ///        "object",
3304    ///        "null"
3305    ///      ],
3306    ///      "required": [
3307    ///        "IsDir",
3308    ///        "MimeType",
3309    ///        "ModTime",
3310    ///        "Name",
3311    ///        "Path",
3312    ///        "Size"
3313    ///      ],
3314    ///      "properties": {
3315    ///        "Encrypted": {
3316    ///          "description": "Encrypted entry name when using crypt
3317    /// remotes.",
3318    ///          "type": "string"
3319    ///        },
3320    ///        "EncryptedPath": {
3321    ///          "description": "Encrypted path when using crypt remotes.",
3322    ///          "type": "string"
3323    ///        },
3324    ///        "Hashes": {
3325    ///          "description": "Hash digests keyed by algorithm when
3326    /// requested.",
3327    ///          "type": "object",
3328    ///          "additionalProperties": {
3329    ///            "type": "string"
3330    ///          }
3331    ///        },
3332    ///        "ID": {
3333    ///          "description": "Backend-specific identifier when provided.",
3334    ///          "type": "string"
3335    ///        },
3336    ///        "IsBucket": {
3337    ///          "description": "True for bucket/root entries on bucket-based
3338    /// remotes.",
3339    ///          "type": "boolean"
3340    ///        },
3341    ///        "IsDir": {
3342    ///          "description": "True if the entry is a directory.",
3343    ///          "type": "boolean"
3344    ///        },
3345    ///        "Metadata": {
3346    ///          "description": "Backend-provided metadata map.",
3347    ///          "type": "object",
3348    ///          "additionalProperties": {}
3349    ///        },
3350    ///        "MimeType": {
3351    ///          "description": "MIME type where available.",
3352    ///          "type": "string"
3353    ///        },
3354    ///        "ModTime": {
3355    ///          "description": "Modification timestamp in RFC3339 format.",
3356    ///          "type": "string"
3357    ///        },
3358    ///        "Name": {
3359    ///          "description": "Base name of the entry.",
3360    ///          "type": "string"
3361    ///        },
3362    ///        "OrigID": {
3363    ///          "description": "Original backend identifier when recorded.",
3364    ///          "type": "string"
3365    ///        },
3366    ///        "Path": {
3367    ///          "description": "Path relative to the remote root.",
3368    ///          "type": "string"
3369    ///        },
3370    ///        "Size": {
3371    ///          "description": "Object size in bytes.",
3372    ///          "type": "number"
3373    ///        },
3374    ///        "Tier": {
3375    ///          "description": "Storage class or tier, if supplied by the
3376    /// backend.",
3377    ///          "type": "string"
3378    ///        }
3379    ///      }
3380    ///    }
3381    ///  }
3382    ///}
3383    /// ```
3384    /// </details>
3385    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3386    pub struct OperationsStatResponse {
3387        pub item: ::std::option::Option<OperationsStatResponseItem>,
3388    }
3389
3390    impl ::std::convert::From<&OperationsStatResponse> for OperationsStatResponse {
3391        fn from(value: &OperationsStatResponse) -> Self {
3392            value.clone()
3393        }
3394    }
3395
3396    ///`OperationsStatResponseItem`
3397    ///
3398    /// <details><summary>JSON schema</summary>
3399    ///
3400    /// ```json
3401    ///{
3402    ///  "type": "object",
3403    ///  "required": [
3404    ///    "IsDir",
3405    ///    "MimeType",
3406    ///    "ModTime",
3407    ///    "Name",
3408    ///    "Path",
3409    ///    "Size"
3410    ///  ],
3411    ///  "properties": {
3412    ///    "Encrypted": {
3413    ///      "description": "Encrypted entry name when using crypt remotes.",
3414    ///      "type": "string"
3415    ///    },
3416    ///    "EncryptedPath": {
3417    ///      "description": "Encrypted path when using crypt remotes.",
3418    ///      "type": "string"
3419    ///    },
3420    ///    "Hashes": {
3421    ///      "description": "Hash digests keyed by algorithm when requested.",
3422    ///      "type": "object",
3423    ///      "additionalProperties": {
3424    ///        "type": "string"
3425    ///      }
3426    ///    },
3427    ///    "ID": {
3428    ///      "description": "Backend-specific identifier when provided.",
3429    ///      "type": "string"
3430    ///    },
3431    ///    "IsBucket": {
3432    ///      "description": "True for bucket/root entries on bucket-based
3433    /// remotes.",
3434    ///      "type": "boolean"
3435    ///    },
3436    ///    "IsDir": {
3437    ///      "description": "True if the entry is a directory.",
3438    ///      "type": "boolean"
3439    ///    },
3440    ///    "Metadata": {
3441    ///      "description": "Backend-provided metadata map.",
3442    ///      "type": "object",
3443    ///      "additionalProperties": {}
3444    ///    },
3445    ///    "MimeType": {
3446    ///      "description": "MIME type where available.",
3447    ///      "type": "string"
3448    ///    },
3449    ///    "ModTime": {
3450    ///      "description": "Modification timestamp in RFC3339 format.",
3451    ///      "type": "string"
3452    ///    },
3453    ///    "Name": {
3454    ///      "description": "Base name of the entry.",
3455    ///      "type": "string"
3456    ///    },
3457    ///    "OrigID": {
3458    ///      "description": "Original backend identifier when recorded.",
3459    ///      "type": "string"
3460    ///    },
3461    ///    "Path": {
3462    ///      "description": "Path relative to the remote root.",
3463    ///      "type": "string"
3464    ///    },
3465    ///    "Size": {
3466    ///      "description": "Object size in bytes.",
3467    ///      "type": "number"
3468    ///    },
3469    ///    "Tier": {
3470    ///      "description": "Storage class or tier, if supplied by the
3471    /// backend.",
3472    ///      "type": "string"
3473    ///    }
3474    ///  }
3475    ///}
3476    /// ```
3477    /// </details>
3478    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3479    pub struct OperationsStatResponseItem {
3480        ///Encrypted entry name when using crypt remotes.
3481        #[serde(
3482            rename = "Encrypted",
3483            default,
3484            skip_serializing_if = "::std::option::Option::is_none"
3485        )]
3486        pub encrypted: ::std::option::Option<::std::string::String>,
3487        ///Encrypted path when using crypt remotes.
3488        #[serde(
3489            rename = "EncryptedPath",
3490            default,
3491            skip_serializing_if = "::std::option::Option::is_none"
3492        )]
3493        pub encrypted_path: ::std::option::Option<::std::string::String>,
3494        ///Hash digests keyed by algorithm when requested.
3495        #[serde(
3496            rename = "Hashes",
3497            default,
3498            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
3499        )]
3500        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3501        ///Backend-specific identifier when provided.
3502        #[serde(
3503            rename = "ID",
3504            default,
3505            skip_serializing_if = "::std::option::Option::is_none"
3506        )]
3507        pub id: ::std::option::Option<::std::string::String>,
3508        ///True for bucket/root entries on bucket-based remotes.
3509        #[serde(
3510            rename = "IsBucket",
3511            default,
3512            skip_serializing_if = "::std::option::Option::is_none"
3513        )]
3514        pub is_bucket: ::std::option::Option<bool>,
3515        ///True if the entry is a directory.
3516        #[serde(rename = "IsDir")]
3517        pub is_dir: bool,
3518        ///Backend-provided metadata map.
3519        #[serde(
3520            rename = "Metadata",
3521            default,
3522            skip_serializing_if = "::serde_json::Map::is_empty"
3523        )]
3524        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3525        ///MIME type where available.
3526        #[serde(rename = "MimeType")]
3527        pub mime_type: ::std::string::String,
3528        ///Modification timestamp in RFC3339 format.
3529        #[serde(rename = "ModTime")]
3530        pub mod_time: ::std::string::String,
3531        ///Base name of the entry.
3532        #[serde(rename = "Name")]
3533        pub name: ::std::string::String,
3534        ///Original backend identifier when recorded.
3535        #[serde(
3536            rename = "OrigID",
3537            default,
3538            skip_serializing_if = "::std::option::Option::is_none"
3539        )]
3540        pub orig_id: ::std::option::Option<::std::string::String>,
3541        ///Path relative to the remote root.
3542        #[serde(rename = "Path")]
3543        pub path: ::std::string::String,
3544        #[serde(rename = "Size")]
3545        pub size: f64,
3546        ///Storage class or tier, if supplied by the backend.
3547        #[serde(
3548            rename = "Tier",
3549            default,
3550            skip_serializing_if = "::std::option::Option::is_none"
3551        )]
3552        pub tier: ::std::option::Option<::std::string::String>,
3553    }
3554
3555    impl ::std::convert::From<&OperationsStatResponseItem> for OperationsStatResponseItem {
3556        fn from(value: &OperationsStatResponseItem) -> Self {
3557            value.clone()
3558        }
3559    }
3560
3561    ///`OptionsBlocksResponse`
3562    ///
3563    /// <details><summary>JSON schema</summary>
3564    ///
3565    /// ```json
3566    ///{
3567    ///  "type": "object",
3568    ///  "required": [
3569    ///    "options"
3570    ///  ],
3571    ///  "properties": {
3572    ///    "options": {
3573    ///      "type": "array",
3574    ///      "items": {
3575    ///        "type": "string"
3576    ///      }
3577    ///    }
3578    ///  }
3579    ///}
3580    /// ```
3581    /// </details>
3582    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3583    pub struct OptionsBlocksResponse {
3584        pub options: ::std::vec::Vec<::std::string::String>,
3585    }
3586
3587    impl ::std::convert::From<&OptionsBlocksResponse> for OptionsBlocksResponse {
3588        fn from(value: &OptionsBlocksResponse) -> Self {
3589            value.clone()
3590        }
3591    }
3592
3593    ///`OptionsGetResponse`
3594    ///
3595    /// <details><summary>JSON schema</summary>
3596    ///
3597    /// ```json
3598    ///{
3599    ///  "type": "object",
3600    ///  "required": [
3601    ///    "dlna",
3602    ///    "filter",
3603    ///    "ftp",
3604    ///    "http",
3605    ///    "log",
3606    ///    "main",
3607    ///    "mount",
3608    ///    "nfs",
3609    ///    "proxy",
3610    ///    "rc",
3611    ///    "restic",
3612    ///    "s3",
3613    ///    "sftp",
3614    ///    "vfs",
3615    ///    "webdav"
3616    ///  ],
3617    ///  "properties": {
3618    ///    "dlna": {
3619    ///      "type": "object",
3620    ///      "additionalProperties": true
3621    ///    },
3622    ///    "filter": {
3623    ///      "type": "object",
3624    ///      "additionalProperties": true
3625    ///    },
3626    ///    "ftp": {
3627    ///      "type": "object",
3628    ///      "additionalProperties": true
3629    ///    },
3630    ///    "http": {
3631    ///      "type": "object",
3632    ///      "additionalProperties": true
3633    ///    },
3634    ///    "log": {
3635    ///      "type": "object",
3636    ///      "additionalProperties": true
3637    ///    },
3638    ///    "main": {
3639    ///      "type": "object",
3640    ///      "additionalProperties": true
3641    ///    },
3642    ///    "mount": {
3643    ///      "type": "object",
3644    ///      "additionalProperties": true
3645    ///    },
3646    ///    "nfs": {
3647    ///      "type": "object",
3648    ///      "additionalProperties": true
3649    ///    },
3650    ///    "proxy": {
3651    ///      "type": "object",
3652    ///      "additionalProperties": true
3653    ///    },
3654    ///    "rc": {
3655    ///      "type": "object",
3656    ///      "additionalProperties": true
3657    ///    },
3658    ///    "restic": {
3659    ///      "type": "object",
3660    ///      "additionalProperties": true
3661    ///    },
3662    ///    "s3": {
3663    ///      "type": "object",
3664    ///      "additionalProperties": true
3665    ///    },
3666    ///    "sftp": {
3667    ///      "type": "object",
3668    ///      "additionalProperties": true
3669    ///    },
3670    ///    "vfs": {
3671    ///      "type": "object",
3672    ///      "additionalProperties": true
3673    ///    },
3674    ///    "webdav": {
3675    ///      "type": "object",
3676    ///      "additionalProperties": true
3677    ///    }
3678    ///  },
3679    ///  "additionalProperties": true
3680    ///}
3681    /// ```
3682    /// </details>
3683    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3684    pub struct OptionsGetResponse {
3685        pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3686        pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3687        pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3688        pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3689        pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3690        pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3691        pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3692        pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3693        pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3694        pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3695        pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3696        pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3697        pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3698        pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3699        pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3700    }
3701
3702    impl ::std::convert::From<&OptionsGetResponse> for OptionsGetResponse {
3703        fn from(value: &OptionsGetResponse) -> Self {
3704            value.clone()
3705        }
3706    }
3707
3708    ///`OptionsInfoOption`
3709    ///
3710    /// <details><summary>JSON schema</summary>
3711    ///
3712    /// ```json
3713    ///{
3714    ///  "type": "object",
3715    ///  "required": [
3716    ///    "Advanced",
3717    ///    "Default",
3718    ///    "DefaultStr",
3719    ///    "Exclusive",
3720    ///    "FieldName",
3721    ///    "Help",
3722    ///    "Hide",
3723    ///    "IsPassword",
3724    ///    "Name",
3725    ///    "NoPrefix",
3726    ///    "Required",
3727    ///    "Sensitive",
3728    ///    "Type",
3729    ///    "Value",
3730    ///    "ValueStr"
3731    ///  ],
3732    ///  "properties": {
3733    ///    "Advanced": {
3734    ///      "type": "boolean"
3735    ///    },
3736    ///    "Default": {
3737    ///      "description": "Default value for this option.",
3738    ///      "anyOf": [
3739    ///        {
3740    ///          "type": "array",
3741    ///          "items": {
3742    ///            "type": "string"
3743    ///          }
3744    ///        },
3745    ///        {
3746    ///          "type": "boolean"
3747    ///        },
3748    ///        {
3749    ///          "type": "number"
3750    ///        },
3751    ///        {
3752    ///          "type": "string"
3753    ///        },
3754    ///        {
3755    ///          "type": "object",
3756    ///          "required": [
3757    ///            "Valid",
3758    ///            "Value"
3759    ///          ],
3760    ///          "properties": {
3761    ///            "Valid": {
3762    ///              "type": "boolean"
3763    ///            },
3764    ///            "Value": {
3765    ///              "type": "boolean"
3766    ///            }
3767    ///          },
3768    ///          "additionalProperties": false
3769    ///        }
3770    ///      ]
3771    ///    },
3772    ///    "DefaultStr": {
3773    ///      "type": "string"
3774    ///    },
3775    ///    "Examples": {
3776    ///      "type": "array",
3777    ///      "items": {
3778    ///        "$ref": "#/components/schemas/OptionsInfoOptionExample"
3779    ///      }
3780    ///    },
3781    ///    "Exclusive": {
3782    ///      "type": "boolean"
3783    ///    },
3784    ///    "FieldName": {
3785    ///      "type": "string"
3786    ///    },
3787    ///    "Groups": {
3788    ///      "type": "string"
3789    ///    },
3790    ///    "Help": {
3791    ///      "type": "string"
3792    ///    },
3793    ///    "Hide": {
3794    ///      "type": "integer"
3795    ///    },
3796    ///    "IsPassword": {
3797    ///      "type": "boolean"
3798    ///    },
3799    ///    "Name": {
3800    ///      "type": "string"
3801    ///    },
3802    ///    "NoPrefix": {
3803    ///      "type": "boolean"
3804    ///    },
3805    ///    "Required": {
3806    ///      "type": "boolean"
3807    ///    },
3808    ///    "Sensitive": {
3809    ///      "type": "boolean"
3810    ///    },
3811    ///    "ShortOpt": {
3812    ///      "type": "string"
3813    ///    },
3814    ///    "Type": {
3815    ///      "type": "string"
3816    ///    },
3817    ///    "Value": {
3818    ///      "oneOf": [
3819    ///        {
3820    ///          "type": "null"
3821    ///        },
3822    ///        {
3823    ///          "anyOf": [
3824    ///            {
3825    ///              "type": "boolean"
3826    ///            },
3827    ///            {
3828    ///              "type": "number"
3829    ///            }
3830    ///          ]
3831    ///        }
3832    ///      ]
3833    ///    },
3834    ///    "ValueStr": {
3835    ///      "type": "string"
3836    ///    }
3837    ///  },
3838    ///  "additionalProperties": true
3839    ///}
3840    /// ```
3841    /// </details>
3842    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3843    pub struct OptionsInfoOption {
3844        #[serde(rename = "Advanced")]
3845        pub advanced: bool,
3846        ///Default value for this option.
3847        #[serde(rename = "Default")]
3848        pub default: OptionsInfoOptionDefault,
3849        #[serde(rename = "DefaultStr")]
3850        pub default_str: ::std::string::String,
3851        #[serde(
3852            rename = "Examples",
3853            default,
3854            skip_serializing_if = "::std::vec::Vec::is_empty"
3855        )]
3856        pub examples: ::std::vec::Vec<OptionsInfoOptionExample>,
3857        #[serde(rename = "Exclusive")]
3858        pub exclusive: bool,
3859        #[serde(rename = "FieldName")]
3860        pub field_name: ::std::string::String,
3861        #[serde(
3862            rename = "Groups",
3863            default,
3864            skip_serializing_if = "::std::option::Option::is_none"
3865        )]
3866        pub groups: ::std::option::Option<::std::string::String>,
3867        #[serde(rename = "Help")]
3868        pub help: ::std::string::String,
3869        #[serde(rename = "Hide")]
3870        pub hide: i64,
3871        #[serde(rename = "IsPassword")]
3872        pub is_password: bool,
3873        #[serde(rename = "Name")]
3874        pub name: ::std::string::String,
3875        #[serde(rename = "NoPrefix")]
3876        pub no_prefix: bool,
3877        #[serde(rename = "Required")]
3878        pub required: bool,
3879        #[serde(rename = "Sensitive")]
3880        pub sensitive: bool,
3881        #[serde(
3882            rename = "ShortOpt",
3883            default,
3884            skip_serializing_if = "::std::option::Option::is_none"
3885        )]
3886        pub short_opt: ::std::option::Option<::std::string::String>,
3887        #[serde(rename = "Type")]
3888        pub type_: ::std::string::String,
3889        #[serde(rename = "Value")]
3890        pub value: ::std::option::Option<OptionsInfoOptionValue>,
3891        #[serde(rename = "ValueStr")]
3892        pub value_str: ::std::string::String,
3893    }
3894
3895    impl ::std::convert::From<&OptionsInfoOption> for OptionsInfoOption {
3896        fn from(value: &OptionsInfoOption) -> Self {
3897            value.clone()
3898        }
3899    }
3900
3901    ///Default value for this option.
3902    ///
3903    /// <details><summary>JSON schema</summary>
3904    ///
3905    /// ```json
3906    ///{
3907    ///  "description": "Default value for this option.",
3908    ///  "anyOf": [
3909    ///    {
3910    ///      "type": "array",
3911    ///      "items": {
3912    ///        "type": "string"
3913    ///      }
3914    ///    },
3915    ///    {
3916    ///      "type": "boolean"
3917    ///    },
3918    ///    {
3919    ///      "type": "number"
3920    ///    },
3921    ///    {
3922    ///      "type": "string"
3923    ///    },
3924    ///    {
3925    ///      "type": "object",
3926    ///      "required": [
3927    ///        "Valid",
3928    ///        "Value"
3929    ///      ],
3930    ///      "properties": {
3931    ///        "Valid": {
3932    ///          "type": "boolean"
3933    ///        },
3934    ///        "Value": {
3935    ///          "type": "boolean"
3936    ///        }
3937    ///      },
3938    ///      "additionalProperties": false
3939    ///    }
3940    ///  ]
3941    ///}
3942    /// ```
3943    /// </details>
3944    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3945    #[serde(untagged, deny_unknown_fields)]
3946    pub enum OptionsInfoOptionDefault {
3947        Variant0(::std::vec::Vec<::std::string::String>),
3948        Variant1(bool),
3949        Variant2(f64),
3950        Variant3(::std::string::String),
3951        Variant4 {
3952            #[serde(rename = "Valid")]
3953            valid: bool,
3954            #[serde(rename = "Value")]
3955            value: bool,
3956        },
3957    }
3958
3959    impl ::std::convert::From<&Self> for OptionsInfoOptionDefault {
3960        fn from(value: &OptionsInfoOptionDefault) -> Self {
3961            value.clone()
3962        }
3963    }
3964
3965    impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionDefault {
3966        fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
3967            Self::Variant0(value)
3968        }
3969    }
3970
3971    impl ::std::convert::From<bool> for OptionsInfoOptionDefault {
3972        fn from(value: bool) -> Self {
3973            Self::Variant1(value)
3974        }
3975    }
3976
3977    impl ::std::convert::From<f64> for OptionsInfoOptionDefault {
3978        fn from(value: f64) -> Self {
3979            Self::Variant2(value)
3980        }
3981    }
3982
3983    ///`OptionsInfoOptionExample`
3984    ///
3985    /// <details><summary>JSON schema</summary>
3986    ///
3987    /// ```json
3988    ///{
3989    ///  "type": "object",
3990    ///  "required": [
3991    ///    "Help",
3992    ///    "Value"
3993    ///  ],
3994    ///  "properties": {
3995    ///    "Help": {
3996    ///      "type": "string"
3997    ///    },
3998    ///    "Value": {
3999    ///      "type": "string"
4000    ///    }
4001    ///  },
4002    ///  "additionalProperties": true
4003    ///}
4004    /// ```
4005    /// </details>
4006    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4007    pub struct OptionsInfoOptionExample {
4008        #[serde(rename = "Help")]
4009        pub help: ::std::string::String,
4010        #[serde(rename = "Value")]
4011        pub value: ::std::string::String,
4012    }
4013
4014    impl ::std::convert::From<&OptionsInfoOptionExample> for OptionsInfoOptionExample {
4015        fn from(value: &OptionsInfoOptionExample) -> Self {
4016            value.clone()
4017        }
4018    }
4019
4020    ///`OptionsInfoOptionValue`
4021    ///
4022    /// <details><summary>JSON schema</summary>
4023    ///
4024    /// ```json
4025    ///{
4026    ///  "anyOf": [
4027    ///    {
4028    ///      "type": "boolean"
4029    ///    },
4030    ///    {
4031    ///      "type": "number"
4032    ///    }
4033    ///  ]
4034    ///}
4035    /// ```
4036    /// </details>
4037    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4038    #[serde(untagged)]
4039    pub enum OptionsInfoOptionValue {
4040        Variant0(bool),
4041        Variant1(f64),
4042    }
4043
4044    impl ::std::convert::From<&Self> for OptionsInfoOptionValue {
4045        fn from(value: &OptionsInfoOptionValue) -> Self {
4046            value.clone()
4047        }
4048    }
4049
4050    impl ::std::str::FromStr for OptionsInfoOptionValue {
4051        type Err = self::error::ConversionError;
4052        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4053            if let Ok(v) = value.parse() {
4054                Ok(Self::Variant0(v))
4055            } else if let Ok(v) = value.parse() {
4056                Ok(Self::Variant1(v))
4057            } else {
4058                Err("string conversion failed for all variants".into())
4059            }
4060        }
4061    }
4062
4063    impl ::std::convert::TryFrom<&str> for OptionsInfoOptionValue {
4064        type Error = self::error::ConversionError;
4065        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4066            value.parse()
4067        }
4068    }
4069
4070    impl ::std::convert::TryFrom<&::std::string::String> for OptionsInfoOptionValue {
4071        type Error = self::error::ConversionError;
4072        fn try_from(
4073            value: &::std::string::String,
4074        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4075            value.parse()
4076        }
4077    }
4078
4079    impl ::std::convert::TryFrom<::std::string::String> for OptionsInfoOptionValue {
4080        type Error = self::error::ConversionError;
4081        fn try_from(
4082            value: ::std::string::String,
4083        ) -> ::std::result::Result<Self, self::error::ConversionError> {
4084            value.parse()
4085        }
4086    }
4087
4088    impl ::std::fmt::Display for OptionsInfoOptionValue {
4089        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4090            match self {
4091                Self::Variant0(x) => x.fmt(f),
4092                Self::Variant1(x) => x.fmt(f),
4093            }
4094        }
4095    }
4096
4097    impl ::std::convert::From<bool> for OptionsInfoOptionValue {
4098        fn from(value: bool) -> Self {
4099            Self::Variant0(value)
4100        }
4101    }
4102
4103    impl ::std::convert::From<f64> for OptionsInfoOptionValue {
4104        fn from(value: f64) -> Self {
4105            Self::Variant1(value)
4106        }
4107    }
4108
4109    ///`OptionsInfoResponse`
4110    ///
4111    /// <details><summary>JSON schema</summary>
4112    ///
4113    /// ```json
4114    ///{
4115    ///  "type": "object",
4116    ///  "required": [
4117    ///    "dlna",
4118    ///    "filter",
4119    ///    "ftp",
4120    ///    "http",
4121    ///    "log",
4122    ///    "main",
4123    ///    "mount",
4124    ///    "nfs",
4125    ///    "proxy",
4126    ///    "rc",
4127    ///    "restic",
4128    ///    "s3",
4129    ///    "sftp",
4130    ///    "vfs",
4131    ///    "webdav"
4132    ///  ],
4133    ///  "properties": {
4134    ///    "dlna": {
4135    ///      "type": "array",
4136    ///      "items": {
4137    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4138    ///      }
4139    ///    },
4140    ///    "filter": {
4141    ///      "type": "array",
4142    ///      "items": {
4143    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4144    ///      }
4145    ///    },
4146    ///    "ftp": {
4147    ///      "type": "array",
4148    ///      "items": {
4149    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4150    ///      }
4151    ///    },
4152    ///    "http": {
4153    ///      "type": "array",
4154    ///      "items": {
4155    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4156    ///      }
4157    ///    },
4158    ///    "log": {
4159    ///      "type": "array",
4160    ///      "items": {
4161    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4162    ///      }
4163    ///    },
4164    ///    "main": {
4165    ///      "type": "array",
4166    ///      "items": {
4167    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4168    ///      }
4169    ///    },
4170    ///    "mount": {
4171    ///      "type": "array",
4172    ///      "items": {
4173    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4174    ///      }
4175    ///    },
4176    ///    "nfs": {
4177    ///      "type": "array",
4178    ///      "items": {
4179    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4180    ///      }
4181    ///    },
4182    ///    "proxy": {
4183    ///      "type": "array",
4184    ///      "items": {
4185    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4186    ///      }
4187    ///    },
4188    ///    "rc": {
4189    ///      "type": "array",
4190    ///      "items": {
4191    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4192    ///      }
4193    ///    },
4194    ///    "restic": {
4195    ///      "type": "array",
4196    ///      "items": {
4197    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4198    ///      }
4199    ///    },
4200    ///    "s3": {
4201    ///      "type": "array",
4202    ///      "items": {
4203    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4204    ///      }
4205    ///    },
4206    ///    "sftp": {
4207    ///      "type": "array",
4208    ///      "items": {
4209    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4210    ///      }
4211    ///    },
4212    ///    "vfs": {
4213    ///      "type": "array",
4214    ///      "items": {
4215    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4216    ///      }
4217    ///    },
4218    ///    "webdav": {
4219    ///      "type": "array",
4220    ///      "items": {
4221    ///        "$ref": "#/components/schemas/OptionsInfoOption"
4222    ///      }
4223    ///    }
4224    ///  },
4225    ///  "additionalProperties": {
4226    ///    "type": "array",
4227    ///    "items": {
4228    ///      "$ref": "#/components/schemas/OptionsInfoOption"
4229    ///    }
4230    ///  }
4231    ///}
4232    /// ```
4233    /// </details>
4234    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4235    pub struct OptionsInfoResponse {
4236        pub dlna: ::std::vec::Vec<OptionsInfoOption>,
4237        pub filter: ::std::vec::Vec<OptionsInfoOption>,
4238        pub ftp: ::std::vec::Vec<OptionsInfoOption>,
4239        pub http: ::std::vec::Vec<OptionsInfoOption>,
4240        pub log: ::std::vec::Vec<OptionsInfoOption>,
4241        pub main: ::std::vec::Vec<OptionsInfoOption>,
4242        pub mount: ::std::vec::Vec<OptionsInfoOption>,
4243        pub nfs: ::std::vec::Vec<OptionsInfoOption>,
4244        pub proxy: ::std::vec::Vec<OptionsInfoOption>,
4245        pub rc: ::std::vec::Vec<OptionsInfoOption>,
4246        pub restic: ::std::vec::Vec<OptionsInfoOption>,
4247        pub s3: ::std::vec::Vec<OptionsInfoOption>,
4248        pub sftp: ::std::vec::Vec<OptionsInfoOption>,
4249        pub vfs: ::std::vec::Vec<OptionsInfoOption>,
4250        pub webdav: ::std::vec::Vec<OptionsInfoOption>,
4251        #[serde(flatten)]
4252        pub extra:
4253            ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<OptionsInfoOption>>,
4254    }
4255
4256    impl ::std::convert::From<&OptionsInfoResponse> for OptionsInfoResponse {
4257        fn from(value: &OptionsInfoResponse) -> Self {
4258            value.clone()
4259        }
4260    }
4261
4262    ///`OptionsLocalResponse`
4263    ///
4264    /// <details><summary>JSON schema</summary>
4265    ///
4266    /// ```json
4267    ///{
4268    ///  "type": "object",
4269    ///  "required": [
4270    ///    "config",
4271    ///    "filter"
4272    ///  ],
4273    ///  "properties": {
4274    ///    "config": {
4275    ///      "type": "object",
4276    ///      "required": [
4277    ///        "AskPassword",
4278    ///        "AutoConfirm",
4279    ///        "BackupDir",
4280    ///        "BindAddr",
4281    ///        "BufferSize",
4282    ///        "BwLimit",
4283    ///        "BwLimitFile",
4284    ///        "CaCert",
4285    ///        "CheckFirst",
4286    ///        "CheckSum",
4287    ///        "Checkers",
4288    ///        "ClientCert",
4289    ///        "ClientKey",
4290    ///        "CompareDest",
4291    ///        "ConnectTimeout",
4292    ///        "Cookie",
4293    ///        "CopyDest",
4294    ///        "CutoffMode",
4295    ///        "DataRateUnit",
4296    ///        "DefaultTime",
4297    ///        "DeleteMode",
4298    ///        "DisableFeatures",
4299    ///        "DisableHTTP2",
4300    ///        "DisableHTTPKeepAlives",
4301    ///        "DownloadHeaders",
4302    ///        "DryRun",
4303    ///        "Dump",
4304    ///        "ErrorOnNoTransfer",
4305    ///        "ExpectContinueTimeout",
4306    ///        "FixCase",
4307    ///        "FsCacheExpireDuration",
4308    ///        "FsCacheExpireInterval",
4309    ///        "Headers",
4310    ///        "HumanReadable",
4311    ///        "IgnoreCaseSync",
4312    ///        "IgnoreChecksum",
4313    ///        "IgnoreErrors",
4314    ///        "IgnoreExisting",
4315    ///        "IgnoreSize",
4316    ///        "IgnoreTimes",
4317    ///        "Immutable",
4318    ///        "Inplace",
4319    ///        "InsecureSkipVerify",
4320    ///        "Interactive",
4321    ///        "KvLockTime",
4322    ///        "Links",
4323    ///        "LogLevel",
4324    ///        "LowLevelRetries",
4325    ///        "MaxBacklog",
4326    ///        "MaxBufferMemory",
4327    ///        "MaxDelete",
4328    ///        "MaxDeleteSize",
4329    ///        "MaxDepth",
4330    ///        "MaxDuration",
4331    ///        "MaxStatsGroups",
4332    ///        "MaxTransfer",
4333    ///        "Metadata",
4334    ///        "MetadataMapper",
4335    ///        "MetadataSet",
4336    ///        "ModifyWindow",
4337    ///        "MultiThreadChunkSize",
4338    ///        "MultiThreadCutoff",
4339    ///        "MultiThreadSet",
4340    ///        "MultiThreadStreams",
4341    ///        "MultiThreadWriteBufferSize",
4342    ///        "NoCheckDest",
4343    ///        "NoConsole",
4344    ///        "NoGzip",
4345    ///        "NoTraverse",
4346    ///        "NoUnicodeNormalization",
4347    ///        "NoUpdateDirModTime",
4348    ///        "NoUpdateModTime",
4349    ///        "OrderBy",
4350    ///        "PartialSuffix",
4351    ///        "PasswordCommand",
4352    ///        "Progress",
4353    ///        "ProgressTerminalTitle",
4354    ///        "RefreshTimes",
4355    ///        "Retries",
4356    ///        "RetriesInterval",
4357    ///        "ServerSideAcrossConfigs",
4358    ///        "SizeOnly",
4359    ///        "StatsFileNameLength",
4360    ///        "StatsLogLevel",
4361    ///        "StatsOneLine",
4362    ///        "StatsOneLineDate",
4363    ///        "StatsOneLineDateFormat",
4364    ///        "StreamingUploadCutoff",
4365    ///        "Suffix",
4366    ///        "SuffixKeepExtension",
4367    ///        "TPSLimit",
4368    ///        "TPSLimitBurst",
4369    ///        "TerminalColorMode",
4370    ///        "Timeout",
4371    ///        "TrackRenames",
4372    ///        "TrackRenamesStrategy",
4373    ///        "TrafficClass",
4374    ///        "Transfers",
4375    ///        "UpdateOlder",
4376    ///        "UploadHeaders",
4377    ///        "UseJSONLog",
4378    ///        "UseListR",
4379    ///        "UseMmap",
4380    ///        "UseServerModTime",
4381    ///        "UserAgent"
4382    ///      ],
4383    ///      "properties": {
4384    ///        "AskPassword": {
4385    ///          "type": "boolean"
4386    ///        },
4387    ///        "AutoConfirm": {
4388    ///          "type": "boolean"
4389    ///        },
4390    ///        "BackupDir": {
4391    ///          "type": "string"
4392    ///        },
4393    ///        "BindAddr": {
4394    ///          "type": "string"
4395    ///        },
4396    ///        "BufferSize": {
4397    ///          "type": "number"
4398    ///        },
4399    ///        "BwLimit": {
4400    ///          "type": "string"
4401    ///        },
4402    ///        "BwLimitFile": {
4403    ///          "type": "string"
4404    ///        },
4405    ///        "CaCert": {
4406    ///          "type": "array",
4407    ///          "items": {
4408    ///            "type": "string"
4409    ///          }
4410    ///        },
4411    ///        "CheckFirst": {
4412    ///          "type": "boolean"
4413    ///        },
4414    ///        "CheckSum": {
4415    ///          "type": "boolean"
4416    ///        },
4417    ///        "Checkers": {
4418    ///          "type": "number"
4419    ///        },
4420    ///        "ClientCert": {
4421    ///          "type": "string"
4422    ///        },
4423    ///        "ClientKey": {
4424    ///          "type": "string"
4425    ///        },
4426    ///        "CompareDest": {
4427    ///          "type": "array",
4428    ///          "items": {
4429    ///            "type": "string"
4430    ///          }
4431    ///        },
4432    ///        "ConnectTimeout": {
4433    ///          "type": "number"
4434    ///        },
4435    ///        "Cookie": {
4436    ///          "type": "boolean"
4437    ///        },
4438    ///        "CopyDest": {
4439    ///          "type": "array",
4440    ///          "items": {
4441    ///            "type": "string"
4442    ///          }
4443    ///        },
4444    ///        "CutoffMode": {
4445    ///          "type": "string"
4446    ///        },
4447    ///        "DataRateUnit": {
4448    ///          "type": "string"
4449    ///        },
4450    ///        "DefaultTime": {
4451    ///          "type": "string"
4452    ///        },
4453    ///        "DeleteMode": {
4454    ///          "type": "number"
4455    ///        },
4456    ///        "DisableFeatures": {
4457    ///          "type": [
4458    ///            "string",
4459    ///            "null"
4460    ///          ],
4461    ///          "format": "null"
4462    ///        },
4463    ///        "DisableHTTP2": {
4464    ///          "type": "boolean"
4465    ///        },
4466    ///        "DisableHTTPKeepAlives": {
4467    ///          "type": "boolean"
4468    ///        },
4469    ///        "DownloadHeaders": {
4470    ///          "type": [
4471    ///            "string",
4472    ///            "null"
4473    ///          ],
4474    ///          "format": "null"
4475    ///        },
4476    ///        "DryRun": {
4477    ///          "type": "boolean"
4478    ///        },
4479    ///        "Dump": {
4480    ///          "type": "string"
4481    ///        },
4482    ///        "ErrorOnNoTransfer": {
4483    ///          "type": "boolean"
4484    ///        },
4485    ///        "ExpectContinueTimeout": {
4486    ///          "type": "number"
4487    ///        },
4488    ///        "FixCase": {
4489    ///          "type": "boolean"
4490    ///        },
4491    ///        "FsCacheExpireDuration": {
4492    ///          "type": "number"
4493    ///        },
4494    ///        "FsCacheExpireInterval": {
4495    ///          "type": "number"
4496    ///        },
4497    ///        "Headers": {
4498    ///          "type": [
4499    ///            "string",
4500    ///            "null"
4501    ///          ],
4502    ///          "format": "null"
4503    ///        },
4504    ///        "HumanReadable": {
4505    ///          "type": "boolean"
4506    ///        },
4507    ///        "IgnoreCaseSync": {
4508    ///          "type": "boolean"
4509    ///        },
4510    ///        "IgnoreChecksum": {
4511    ///          "type": "boolean"
4512    ///        },
4513    ///        "IgnoreErrors": {
4514    ///          "type": "boolean"
4515    ///        },
4516    ///        "IgnoreExisting": {
4517    ///          "type": "boolean"
4518    ///        },
4519    ///        "IgnoreSize": {
4520    ///          "type": "boolean"
4521    ///        },
4522    ///        "IgnoreTimes": {
4523    ///          "type": "boolean"
4524    ///        },
4525    ///        "Immutable": {
4526    ///          "type": "boolean"
4527    ///        },
4528    ///        "Inplace": {
4529    ///          "type": "boolean"
4530    ///        },
4531    ///        "InsecureSkipVerify": {
4532    ///          "type": "boolean"
4533    ///        },
4534    ///        "Interactive": {
4535    ///          "type": "boolean"
4536    ///        },
4537    ///        "KvLockTime": {
4538    ///          "type": "number"
4539    ///        },
4540    ///        "Links": {
4541    ///          "type": "boolean"
4542    ///        },
4543    ///        "LogLevel": {
4544    ///          "type": "string"
4545    ///        },
4546    ///        "LowLevelRetries": {
4547    ///          "type": "number"
4548    ///        },
4549    ///        "MaxBacklog": {
4550    ///          "type": "number"
4551    ///        },
4552    ///        "MaxBufferMemory": {
4553    ///          "type": "number"
4554    ///        },
4555    ///        "MaxDelete": {
4556    ///          "type": "number"
4557    ///        },
4558    ///        "MaxDeleteSize": {
4559    ///          "type": "number"
4560    ///        },
4561    ///        "MaxDepth": {
4562    ///          "type": "number"
4563    ///        },
4564    ///        "MaxDuration": {
4565    ///          "type": "number"
4566    ///        },
4567    ///        "MaxStatsGroups": {
4568    ///          "type": "number"
4569    ///        },
4570    ///        "MaxTransfer": {
4571    ///          "type": "number"
4572    ///        },
4573    ///        "Metadata": {
4574    ///          "type": "boolean"
4575    ///        },
4576    ///        "MetadataMapper": {
4577    ///          "type": [
4578    ///            "string",
4579    ///            "null"
4580    ///          ],
4581    ///          "format": "null"
4582    ///        },
4583    ///        "MetadataSet": {
4584    ///          "type": [
4585    ///            "string",
4586    ///            "null"
4587    ///          ],
4588    ///          "format": "null"
4589    ///        },
4590    ///        "ModifyWindow": {
4591    ///          "type": "number"
4592    ///        },
4593    ///        "MultiThreadChunkSize": {
4594    ///          "type": "number"
4595    ///        },
4596    ///        "MultiThreadCutoff": {
4597    ///          "type": "number"
4598    ///        },
4599    ///        "MultiThreadSet": {
4600    ///          "type": "boolean"
4601    ///        },
4602    ///        "MultiThreadStreams": {
4603    ///          "type": "number"
4604    ///        },
4605    ///        "MultiThreadWriteBufferSize": {
4606    ///          "type": "number"
4607    ///        },
4608    ///        "NoCheckDest": {
4609    ///          "type": "boolean"
4610    ///        },
4611    ///        "NoConsole": {
4612    ///          "type": "boolean"
4613    ///        },
4614    ///        "NoGzip": {
4615    ///          "type": "boolean"
4616    ///        },
4617    ///        "NoTraverse": {
4618    ///          "type": "boolean"
4619    ///        },
4620    ///        "NoUnicodeNormalization": {
4621    ///          "type": "boolean"
4622    ///        },
4623    ///        "NoUpdateDirModTime": {
4624    ///          "type": "boolean"
4625    ///        },
4626    ///        "NoUpdateModTime": {
4627    ///          "type": "boolean"
4628    ///        },
4629    ///        "OrderBy": {
4630    ///          "type": "string"
4631    ///        },
4632    ///        "PartialSuffix": {
4633    ///          "type": "string"
4634    ///        },
4635    ///        "PasswordCommand": {
4636    ///          "type": [
4637    ///            "string",
4638    ///            "null"
4639    ///          ],
4640    ///          "format": "null"
4641    ///        },
4642    ///        "Progress": {
4643    ///          "type": "boolean"
4644    ///        },
4645    ///        "ProgressTerminalTitle": {
4646    ///          "type": "boolean"
4647    ///        },
4648    ///        "RefreshTimes": {
4649    ///          "type": "boolean"
4650    ///        },
4651    ///        "Retries": {
4652    ///          "type": "number"
4653    ///        },
4654    ///        "RetriesInterval": {
4655    ///          "type": "number"
4656    ///        },
4657    ///        "ServerSideAcrossConfigs": {
4658    ///          "type": "boolean"
4659    ///        },
4660    ///        "SizeOnly": {
4661    ///          "type": "boolean"
4662    ///        },
4663    ///        "StatsFileNameLength": {
4664    ///          "type": "number"
4665    ///        },
4666    ///        "StatsLogLevel": {
4667    ///          "type": "string"
4668    ///        },
4669    ///        "StatsOneLine": {
4670    ///          "type": "boolean"
4671    ///        },
4672    ///        "StatsOneLineDate": {
4673    ///          "type": "boolean"
4674    ///        },
4675    ///        "StatsOneLineDateFormat": {
4676    ///          "type": "string"
4677    ///        },
4678    ///        "StreamingUploadCutoff": {
4679    ///          "type": "number"
4680    ///        },
4681    ///        "Suffix": {
4682    ///          "type": "string"
4683    ///        },
4684    ///        "SuffixKeepExtension": {
4685    ///          "type": "boolean"
4686    ///        },
4687    ///        "TPSLimit": {
4688    ///          "type": "number"
4689    ///        },
4690    ///        "TPSLimitBurst": {
4691    ///          "type": "number"
4692    ///        },
4693    ///        "TerminalColorMode": {
4694    ///          "type": "string"
4695    ///        },
4696    ///        "Timeout": {
4697    ///          "type": "number"
4698    ///        },
4699    ///        "TrackRenames": {
4700    ///          "type": "boolean"
4701    ///        },
4702    ///        "TrackRenamesStrategy": {
4703    ///          "type": "string"
4704    ///        },
4705    ///        "TrafficClass": {
4706    ///          "type": "number"
4707    ///        },
4708    ///        "Transfers": {
4709    ///          "type": "number"
4710    ///        },
4711    ///        "UpdateOlder": {
4712    ///          "type": "boolean"
4713    ///        },
4714    ///        "UploadHeaders": {
4715    ///          "type": [
4716    ///            "string",
4717    ///            "null"
4718    ///          ],
4719    ///          "format": "null"
4720    ///        },
4721    ///        "UseJSONLog": {
4722    ///          "type": "boolean"
4723    ///        },
4724    ///        "UseListR": {
4725    ///          "type": "boolean"
4726    ///        },
4727    ///        "UseMmap": {
4728    ///          "type": "boolean"
4729    ///        },
4730    ///        "UseServerModTime": {
4731    ///          "type": "boolean"
4732    ///        },
4733    ///        "UserAgent": {
4734    ///          "type": "string"
4735    ///        }
4736    ///      }
4737    ///    },
4738    ///    "filter": {
4739    ///      "type": "object",
4740    ///      "required": [
4741    ///        "DeleteExcluded",
4742    ///        "ExcludeFile",
4743    ///        "ExcludeFrom",
4744    ///        "ExcludeRule",
4745    ///        "FilesFrom",
4746    ///        "FilesFromRaw",
4747    ///        "FilterFrom",
4748    ///        "FilterRule",
4749    ///        "HashFilter",
4750    ///        "IgnoreCase",
4751    ///        "IncludeFrom",
4752    ///        "IncludeRule",
4753    ///        "MaxAge",
4754    ///        "MaxSize",
4755    ///        "MetaRules",
4756    ///        "MinAge",
4757    ///        "MinSize"
4758    ///      ],
4759    ///      "properties": {
4760    ///        "DeleteExcluded": {
4761    ///          "type": "boolean"
4762    ///        },
4763    ///        "ExcludeFile": {
4764    ///          "type": "array",
4765    ///          "items": {
4766    ///            "type": "string"
4767    ///          }
4768    ///        },
4769    ///        "ExcludeFrom": {
4770    ///          "type": "array",
4771    ///          "items": {
4772    ///            "type": "string"
4773    ///          }
4774    ///        },
4775    ///        "ExcludeRule": {
4776    ///          "type": "array",
4777    ///          "items": {
4778    ///            "type": "string"
4779    ///          }
4780    ///        },
4781    ///        "FilesFrom": {
4782    ///          "type": "array",
4783    ///          "items": {
4784    ///            "type": "string"
4785    ///          }
4786    ///        },
4787    ///        "FilesFromRaw": {
4788    ///          "type": "array",
4789    ///          "items": {
4790    ///            "type": "string"
4791    ///          }
4792    ///        },
4793    ///        "FilterFrom": {
4794    ///          "type": "array",
4795    ///          "items": {
4796    ///            "type": "string"
4797    ///          }
4798    ///        },
4799    ///        "FilterRule": {
4800    ///          "type": "array",
4801    ///          "items": {
4802    ///            "type": "string"
4803    ///          }
4804    ///        },
4805    ///        "HashFilter": {
4806    ///          "type": "string"
4807    ///        },
4808    ///        "IgnoreCase": {
4809    ///          "type": "boolean"
4810    ///        },
4811    ///        "IncludeFrom": {
4812    ///          "type": "array",
4813    ///          "items": {
4814    ///            "type": "string"
4815    ///          }
4816    ///        },
4817    ///        "IncludeRule": {
4818    ///          "type": "array",
4819    ///          "items": {
4820    ///            "type": "string"
4821    ///          }
4822    ///        },
4823    ///        "MaxAge": {
4824    ///          "type": "number"
4825    ///        },
4826    ///        "MaxSize": {
4827    ///          "type": "number"
4828    ///        },
4829    ///        "MetaRules": {
4830    ///          "type": "object",
4831    ///          "required": [
4832    ///            "ExcludeFrom",
4833    ///            "ExcludeRule",
4834    ///            "FilterFrom",
4835    ///            "FilterRule",
4836    ///            "IncludeFrom",
4837    ///            "IncludeRule"
4838    ///          ],
4839    ///          "properties": {
4840    ///            "ExcludeFrom": {
4841    ///              "type": "array",
4842    ///              "items": {
4843    ///                "type": "string"
4844    ///              }
4845    ///            },
4846    ///            "ExcludeRule": {
4847    ///              "type": "array",
4848    ///              "items": {
4849    ///                "type": "string"
4850    ///              }
4851    ///            },
4852    ///            "FilterFrom": {
4853    ///              "type": "array",
4854    ///              "items": {
4855    ///                "type": "string"
4856    ///              }
4857    ///            },
4858    ///            "FilterRule": {
4859    ///              "type": "array",
4860    ///              "items": {
4861    ///                "type": "string"
4862    ///              }
4863    ///            },
4864    ///            "IncludeFrom": {
4865    ///              "type": "array",
4866    ///              "items": {
4867    ///                "type": "string"
4868    ///              }
4869    ///            },
4870    ///            "IncludeRule": {
4871    ///              "type": "array",
4872    ///              "items": {
4873    ///                "type": "string"
4874    ///              }
4875    ///            }
4876    ///          }
4877    ///        },
4878    ///        "MinAge": {
4879    ///          "type": "number"
4880    ///        },
4881    ///        "MinSize": {
4882    ///          "type": "number"
4883    ///        }
4884    ///      }
4885    ///    }
4886    ///  }
4887    ///}
4888    /// ```
4889    /// </details>
4890    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4891    pub struct OptionsLocalResponse {
4892        pub config: OptionsLocalResponseConfig,
4893        pub filter: OptionsLocalResponseFilter,
4894    }
4895
4896    impl ::std::convert::From<&OptionsLocalResponse> for OptionsLocalResponse {
4897        fn from(value: &OptionsLocalResponse) -> Self {
4898            value.clone()
4899        }
4900    }
4901
4902    ///`OptionsLocalResponseConfig`
4903    ///
4904    /// <details><summary>JSON schema</summary>
4905    ///
4906    /// ```json
4907    ///{
4908    ///  "type": "object",
4909    ///  "required": [
4910    ///    "AskPassword",
4911    ///    "AutoConfirm",
4912    ///    "BackupDir",
4913    ///    "BindAddr",
4914    ///    "BufferSize",
4915    ///    "BwLimit",
4916    ///    "BwLimitFile",
4917    ///    "CaCert",
4918    ///    "CheckFirst",
4919    ///    "CheckSum",
4920    ///    "Checkers",
4921    ///    "ClientCert",
4922    ///    "ClientKey",
4923    ///    "CompareDest",
4924    ///    "ConnectTimeout",
4925    ///    "Cookie",
4926    ///    "CopyDest",
4927    ///    "CutoffMode",
4928    ///    "DataRateUnit",
4929    ///    "DefaultTime",
4930    ///    "DeleteMode",
4931    ///    "DisableFeatures",
4932    ///    "DisableHTTP2",
4933    ///    "DisableHTTPKeepAlives",
4934    ///    "DownloadHeaders",
4935    ///    "DryRun",
4936    ///    "Dump",
4937    ///    "ErrorOnNoTransfer",
4938    ///    "ExpectContinueTimeout",
4939    ///    "FixCase",
4940    ///    "FsCacheExpireDuration",
4941    ///    "FsCacheExpireInterval",
4942    ///    "Headers",
4943    ///    "HumanReadable",
4944    ///    "IgnoreCaseSync",
4945    ///    "IgnoreChecksum",
4946    ///    "IgnoreErrors",
4947    ///    "IgnoreExisting",
4948    ///    "IgnoreSize",
4949    ///    "IgnoreTimes",
4950    ///    "Immutable",
4951    ///    "Inplace",
4952    ///    "InsecureSkipVerify",
4953    ///    "Interactive",
4954    ///    "KvLockTime",
4955    ///    "Links",
4956    ///    "LogLevel",
4957    ///    "LowLevelRetries",
4958    ///    "MaxBacklog",
4959    ///    "MaxBufferMemory",
4960    ///    "MaxDelete",
4961    ///    "MaxDeleteSize",
4962    ///    "MaxDepth",
4963    ///    "MaxDuration",
4964    ///    "MaxStatsGroups",
4965    ///    "MaxTransfer",
4966    ///    "Metadata",
4967    ///    "MetadataMapper",
4968    ///    "MetadataSet",
4969    ///    "ModifyWindow",
4970    ///    "MultiThreadChunkSize",
4971    ///    "MultiThreadCutoff",
4972    ///    "MultiThreadSet",
4973    ///    "MultiThreadStreams",
4974    ///    "MultiThreadWriteBufferSize",
4975    ///    "NoCheckDest",
4976    ///    "NoConsole",
4977    ///    "NoGzip",
4978    ///    "NoTraverse",
4979    ///    "NoUnicodeNormalization",
4980    ///    "NoUpdateDirModTime",
4981    ///    "NoUpdateModTime",
4982    ///    "OrderBy",
4983    ///    "PartialSuffix",
4984    ///    "PasswordCommand",
4985    ///    "Progress",
4986    ///    "ProgressTerminalTitle",
4987    ///    "RefreshTimes",
4988    ///    "Retries",
4989    ///    "RetriesInterval",
4990    ///    "ServerSideAcrossConfigs",
4991    ///    "SizeOnly",
4992    ///    "StatsFileNameLength",
4993    ///    "StatsLogLevel",
4994    ///    "StatsOneLine",
4995    ///    "StatsOneLineDate",
4996    ///    "StatsOneLineDateFormat",
4997    ///    "StreamingUploadCutoff",
4998    ///    "Suffix",
4999    ///    "SuffixKeepExtension",
5000    ///    "TPSLimit",
5001    ///    "TPSLimitBurst",
5002    ///    "TerminalColorMode",
5003    ///    "Timeout",
5004    ///    "TrackRenames",
5005    ///    "TrackRenamesStrategy",
5006    ///    "TrafficClass",
5007    ///    "Transfers",
5008    ///    "UpdateOlder",
5009    ///    "UploadHeaders",
5010    ///    "UseJSONLog",
5011    ///    "UseListR",
5012    ///    "UseMmap",
5013    ///    "UseServerModTime",
5014    ///    "UserAgent"
5015    ///  ],
5016    ///  "properties": {
5017    ///    "AskPassword": {
5018    ///      "type": "boolean"
5019    ///    },
5020    ///    "AutoConfirm": {
5021    ///      "type": "boolean"
5022    ///    },
5023    ///    "BackupDir": {
5024    ///      "type": "string"
5025    ///    },
5026    ///    "BindAddr": {
5027    ///      "type": "string"
5028    ///    },
5029    ///    "BufferSize": {
5030    ///      "type": "number"
5031    ///    },
5032    ///    "BwLimit": {
5033    ///      "type": "string"
5034    ///    },
5035    ///    "BwLimitFile": {
5036    ///      "type": "string"
5037    ///    },
5038    ///    "CaCert": {
5039    ///      "type": "array",
5040    ///      "items": {
5041    ///        "type": "string"
5042    ///      }
5043    ///    },
5044    ///    "CheckFirst": {
5045    ///      "type": "boolean"
5046    ///    },
5047    ///    "CheckSum": {
5048    ///      "type": "boolean"
5049    ///    },
5050    ///    "Checkers": {
5051    ///      "type": "number"
5052    ///    },
5053    ///    "ClientCert": {
5054    ///      "type": "string"
5055    ///    },
5056    ///    "ClientKey": {
5057    ///      "type": "string"
5058    ///    },
5059    ///    "CompareDest": {
5060    ///      "type": "array",
5061    ///      "items": {
5062    ///        "type": "string"
5063    ///      }
5064    ///    },
5065    ///    "ConnectTimeout": {
5066    ///      "type": "number"
5067    ///    },
5068    ///    "Cookie": {
5069    ///      "type": "boolean"
5070    ///    },
5071    ///    "CopyDest": {
5072    ///      "type": "array",
5073    ///      "items": {
5074    ///        "type": "string"
5075    ///      }
5076    ///    },
5077    ///    "CutoffMode": {
5078    ///      "type": "string"
5079    ///    },
5080    ///    "DataRateUnit": {
5081    ///      "type": "string"
5082    ///    },
5083    ///    "DefaultTime": {
5084    ///      "type": "string"
5085    ///    },
5086    ///    "DeleteMode": {
5087    ///      "type": "number"
5088    ///    },
5089    ///    "DisableFeatures": {
5090    ///      "type": [
5091    ///        "string",
5092    ///        "null"
5093    ///      ],
5094    ///      "format": "null"
5095    ///    },
5096    ///    "DisableHTTP2": {
5097    ///      "type": "boolean"
5098    ///    },
5099    ///    "DisableHTTPKeepAlives": {
5100    ///      "type": "boolean"
5101    ///    },
5102    ///    "DownloadHeaders": {
5103    ///      "type": [
5104    ///        "string",
5105    ///        "null"
5106    ///      ],
5107    ///      "format": "null"
5108    ///    },
5109    ///    "DryRun": {
5110    ///      "type": "boolean"
5111    ///    },
5112    ///    "Dump": {
5113    ///      "type": "string"
5114    ///    },
5115    ///    "ErrorOnNoTransfer": {
5116    ///      "type": "boolean"
5117    ///    },
5118    ///    "ExpectContinueTimeout": {
5119    ///      "type": "number"
5120    ///    },
5121    ///    "FixCase": {
5122    ///      "type": "boolean"
5123    ///    },
5124    ///    "FsCacheExpireDuration": {
5125    ///      "type": "number"
5126    ///    },
5127    ///    "FsCacheExpireInterval": {
5128    ///      "type": "number"
5129    ///    },
5130    ///    "Headers": {
5131    ///      "type": [
5132    ///        "string",
5133    ///        "null"
5134    ///      ],
5135    ///      "format": "null"
5136    ///    },
5137    ///    "HumanReadable": {
5138    ///      "type": "boolean"
5139    ///    },
5140    ///    "IgnoreCaseSync": {
5141    ///      "type": "boolean"
5142    ///    },
5143    ///    "IgnoreChecksum": {
5144    ///      "type": "boolean"
5145    ///    },
5146    ///    "IgnoreErrors": {
5147    ///      "type": "boolean"
5148    ///    },
5149    ///    "IgnoreExisting": {
5150    ///      "type": "boolean"
5151    ///    },
5152    ///    "IgnoreSize": {
5153    ///      "type": "boolean"
5154    ///    },
5155    ///    "IgnoreTimes": {
5156    ///      "type": "boolean"
5157    ///    },
5158    ///    "Immutable": {
5159    ///      "type": "boolean"
5160    ///    },
5161    ///    "Inplace": {
5162    ///      "type": "boolean"
5163    ///    },
5164    ///    "InsecureSkipVerify": {
5165    ///      "type": "boolean"
5166    ///    },
5167    ///    "Interactive": {
5168    ///      "type": "boolean"
5169    ///    },
5170    ///    "KvLockTime": {
5171    ///      "type": "number"
5172    ///    },
5173    ///    "Links": {
5174    ///      "type": "boolean"
5175    ///    },
5176    ///    "LogLevel": {
5177    ///      "type": "string"
5178    ///    },
5179    ///    "LowLevelRetries": {
5180    ///      "type": "number"
5181    ///    },
5182    ///    "MaxBacklog": {
5183    ///      "type": "number"
5184    ///    },
5185    ///    "MaxBufferMemory": {
5186    ///      "type": "number"
5187    ///    },
5188    ///    "MaxDelete": {
5189    ///      "type": "number"
5190    ///    },
5191    ///    "MaxDeleteSize": {
5192    ///      "type": "number"
5193    ///    },
5194    ///    "MaxDepth": {
5195    ///      "type": "number"
5196    ///    },
5197    ///    "MaxDuration": {
5198    ///      "type": "number"
5199    ///    },
5200    ///    "MaxStatsGroups": {
5201    ///      "type": "number"
5202    ///    },
5203    ///    "MaxTransfer": {
5204    ///      "type": "number"
5205    ///    },
5206    ///    "Metadata": {
5207    ///      "type": "boolean"
5208    ///    },
5209    ///    "MetadataMapper": {
5210    ///      "type": [
5211    ///        "string",
5212    ///        "null"
5213    ///      ],
5214    ///      "format": "null"
5215    ///    },
5216    ///    "MetadataSet": {
5217    ///      "type": [
5218    ///        "string",
5219    ///        "null"
5220    ///      ],
5221    ///      "format": "null"
5222    ///    },
5223    ///    "ModifyWindow": {
5224    ///      "type": "number"
5225    ///    },
5226    ///    "MultiThreadChunkSize": {
5227    ///      "type": "number"
5228    ///    },
5229    ///    "MultiThreadCutoff": {
5230    ///      "type": "number"
5231    ///    },
5232    ///    "MultiThreadSet": {
5233    ///      "type": "boolean"
5234    ///    },
5235    ///    "MultiThreadStreams": {
5236    ///      "type": "number"
5237    ///    },
5238    ///    "MultiThreadWriteBufferSize": {
5239    ///      "type": "number"
5240    ///    },
5241    ///    "NoCheckDest": {
5242    ///      "type": "boolean"
5243    ///    },
5244    ///    "NoConsole": {
5245    ///      "type": "boolean"
5246    ///    },
5247    ///    "NoGzip": {
5248    ///      "type": "boolean"
5249    ///    },
5250    ///    "NoTraverse": {
5251    ///      "type": "boolean"
5252    ///    },
5253    ///    "NoUnicodeNormalization": {
5254    ///      "type": "boolean"
5255    ///    },
5256    ///    "NoUpdateDirModTime": {
5257    ///      "type": "boolean"
5258    ///    },
5259    ///    "NoUpdateModTime": {
5260    ///      "type": "boolean"
5261    ///    },
5262    ///    "OrderBy": {
5263    ///      "type": "string"
5264    ///    },
5265    ///    "PartialSuffix": {
5266    ///      "type": "string"
5267    ///    },
5268    ///    "PasswordCommand": {
5269    ///      "type": [
5270    ///        "string",
5271    ///        "null"
5272    ///      ],
5273    ///      "format": "null"
5274    ///    },
5275    ///    "Progress": {
5276    ///      "type": "boolean"
5277    ///    },
5278    ///    "ProgressTerminalTitle": {
5279    ///      "type": "boolean"
5280    ///    },
5281    ///    "RefreshTimes": {
5282    ///      "type": "boolean"
5283    ///    },
5284    ///    "Retries": {
5285    ///      "type": "number"
5286    ///    },
5287    ///    "RetriesInterval": {
5288    ///      "type": "number"
5289    ///    },
5290    ///    "ServerSideAcrossConfigs": {
5291    ///      "type": "boolean"
5292    ///    },
5293    ///    "SizeOnly": {
5294    ///      "type": "boolean"
5295    ///    },
5296    ///    "StatsFileNameLength": {
5297    ///      "type": "number"
5298    ///    },
5299    ///    "StatsLogLevel": {
5300    ///      "type": "string"
5301    ///    },
5302    ///    "StatsOneLine": {
5303    ///      "type": "boolean"
5304    ///    },
5305    ///    "StatsOneLineDate": {
5306    ///      "type": "boolean"
5307    ///    },
5308    ///    "StatsOneLineDateFormat": {
5309    ///      "type": "string"
5310    ///    },
5311    ///    "StreamingUploadCutoff": {
5312    ///      "type": "number"
5313    ///    },
5314    ///    "Suffix": {
5315    ///      "type": "string"
5316    ///    },
5317    ///    "SuffixKeepExtension": {
5318    ///      "type": "boolean"
5319    ///    },
5320    ///    "TPSLimit": {
5321    ///      "type": "number"
5322    ///    },
5323    ///    "TPSLimitBurst": {
5324    ///      "type": "number"
5325    ///    },
5326    ///    "TerminalColorMode": {
5327    ///      "type": "string"
5328    ///    },
5329    ///    "Timeout": {
5330    ///      "type": "number"
5331    ///    },
5332    ///    "TrackRenames": {
5333    ///      "type": "boolean"
5334    ///    },
5335    ///    "TrackRenamesStrategy": {
5336    ///      "type": "string"
5337    ///    },
5338    ///    "TrafficClass": {
5339    ///      "type": "number"
5340    ///    },
5341    ///    "Transfers": {
5342    ///      "type": "number"
5343    ///    },
5344    ///    "UpdateOlder": {
5345    ///      "type": "boolean"
5346    ///    },
5347    ///    "UploadHeaders": {
5348    ///      "type": [
5349    ///        "string",
5350    ///        "null"
5351    ///      ],
5352    ///      "format": "null"
5353    ///    },
5354    ///    "UseJSONLog": {
5355    ///      "type": "boolean"
5356    ///    },
5357    ///    "UseListR": {
5358    ///      "type": "boolean"
5359    ///    },
5360    ///    "UseMmap": {
5361    ///      "type": "boolean"
5362    ///    },
5363    ///    "UseServerModTime": {
5364    ///      "type": "boolean"
5365    ///    },
5366    ///    "UserAgent": {
5367    ///      "type": "string"
5368    ///    }
5369    ///  }
5370    ///}
5371    /// ```
5372    /// </details>
5373    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5374    pub struct OptionsLocalResponseConfig {
5375        #[serde(rename = "AskPassword")]
5376        pub ask_password: bool,
5377        #[serde(rename = "AutoConfirm")]
5378        pub auto_confirm: bool,
5379        #[serde(rename = "BackupDir")]
5380        pub backup_dir: ::std::string::String,
5381        #[serde(rename = "BindAddr")]
5382        pub bind_addr: ::std::string::String,
5383        #[serde(rename = "BufferSize")]
5384        pub buffer_size: f64,
5385        #[serde(rename = "BwLimit")]
5386        pub bw_limit: ::std::string::String,
5387        #[serde(rename = "BwLimitFile")]
5388        pub bw_limit_file: ::std::string::String,
5389        #[serde(rename = "CaCert")]
5390        pub ca_cert: ::std::vec::Vec<::std::string::String>,
5391        #[serde(rename = "CheckFirst")]
5392        pub check_first: bool,
5393        #[serde(rename = "CheckSum")]
5394        pub check_sum: bool,
5395        #[serde(rename = "Checkers")]
5396        pub checkers: f64,
5397        #[serde(rename = "ClientCert")]
5398        pub client_cert: ::std::string::String,
5399        #[serde(rename = "ClientKey")]
5400        pub client_key: ::std::string::String,
5401        #[serde(rename = "CompareDest")]
5402        pub compare_dest: ::std::vec::Vec<::std::string::String>,
5403        #[serde(rename = "ConnectTimeout")]
5404        pub connect_timeout: f64,
5405        #[serde(rename = "Cookie")]
5406        pub cookie: bool,
5407        #[serde(rename = "CopyDest")]
5408        pub copy_dest: ::std::vec::Vec<::std::string::String>,
5409        #[serde(rename = "CutoffMode")]
5410        pub cutoff_mode: ::std::string::String,
5411        #[serde(rename = "DataRateUnit")]
5412        pub data_rate_unit: ::std::string::String,
5413        #[serde(rename = "DefaultTime")]
5414        pub default_time: ::std::string::String,
5415        #[serde(rename = "DeleteMode")]
5416        pub delete_mode: f64,
5417        #[serde(rename = "DisableFeatures")]
5418        pub disable_features: ::std::option::Option<::std::string::String>,
5419        #[serde(rename = "DisableHTTP2")]
5420        pub disable_http2: bool,
5421        #[serde(rename = "DisableHTTPKeepAlives")]
5422        pub disable_http_keep_alives: bool,
5423        #[serde(rename = "DownloadHeaders")]
5424        pub download_headers: ::std::option::Option<::std::string::String>,
5425        #[serde(rename = "DryRun")]
5426        pub dry_run: bool,
5427        #[serde(rename = "Dump")]
5428        pub dump: ::std::string::String,
5429        #[serde(rename = "ErrorOnNoTransfer")]
5430        pub error_on_no_transfer: bool,
5431        #[serde(rename = "ExpectContinueTimeout")]
5432        pub expect_continue_timeout: f64,
5433        #[serde(rename = "FixCase")]
5434        pub fix_case: bool,
5435        #[serde(rename = "FsCacheExpireDuration")]
5436        pub fs_cache_expire_duration: f64,
5437        #[serde(rename = "FsCacheExpireInterval")]
5438        pub fs_cache_expire_interval: f64,
5439        #[serde(rename = "Headers")]
5440        pub headers: ::std::option::Option<::std::string::String>,
5441        #[serde(rename = "HumanReadable")]
5442        pub human_readable: bool,
5443        #[serde(rename = "IgnoreCaseSync")]
5444        pub ignore_case_sync: bool,
5445        #[serde(rename = "IgnoreChecksum")]
5446        pub ignore_checksum: bool,
5447        #[serde(rename = "IgnoreErrors")]
5448        pub ignore_errors: bool,
5449        #[serde(rename = "IgnoreExisting")]
5450        pub ignore_existing: bool,
5451        #[serde(rename = "IgnoreSize")]
5452        pub ignore_size: bool,
5453        #[serde(rename = "IgnoreTimes")]
5454        pub ignore_times: bool,
5455        #[serde(rename = "Immutable")]
5456        pub immutable: bool,
5457        #[serde(rename = "Inplace")]
5458        pub inplace: bool,
5459        #[serde(rename = "InsecureSkipVerify")]
5460        pub insecure_skip_verify: bool,
5461        #[serde(rename = "Interactive")]
5462        pub interactive: bool,
5463        #[serde(rename = "KvLockTime")]
5464        pub kv_lock_time: f64,
5465        #[serde(rename = "Links")]
5466        pub links: bool,
5467        #[serde(rename = "LogLevel")]
5468        pub log_level: ::std::string::String,
5469        #[serde(rename = "LowLevelRetries")]
5470        pub low_level_retries: f64,
5471        #[serde(rename = "MaxBacklog")]
5472        pub max_backlog: f64,
5473        #[serde(rename = "MaxBufferMemory")]
5474        pub max_buffer_memory: f64,
5475        #[serde(rename = "MaxDelete")]
5476        pub max_delete: f64,
5477        #[serde(rename = "MaxDeleteSize")]
5478        pub max_delete_size: f64,
5479        #[serde(rename = "MaxDepth")]
5480        pub max_depth: f64,
5481        #[serde(rename = "MaxDuration")]
5482        pub max_duration: f64,
5483        #[serde(rename = "MaxStatsGroups")]
5484        pub max_stats_groups: f64,
5485        #[serde(rename = "MaxTransfer")]
5486        pub max_transfer: f64,
5487        #[serde(rename = "Metadata")]
5488        pub metadata: bool,
5489        #[serde(rename = "MetadataMapper")]
5490        pub metadata_mapper: ::std::option::Option<::std::string::String>,
5491        #[serde(rename = "MetadataSet")]
5492        pub metadata_set: ::std::option::Option<::std::string::String>,
5493        #[serde(rename = "ModifyWindow")]
5494        pub modify_window: f64,
5495        #[serde(rename = "MultiThreadChunkSize")]
5496        pub multi_thread_chunk_size: f64,
5497        #[serde(rename = "MultiThreadCutoff")]
5498        pub multi_thread_cutoff: f64,
5499        #[serde(rename = "MultiThreadSet")]
5500        pub multi_thread_set: bool,
5501        #[serde(rename = "MultiThreadStreams")]
5502        pub multi_thread_streams: f64,
5503        #[serde(rename = "MultiThreadWriteBufferSize")]
5504        pub multi_thread_write_buffer_size: f64,
5505        #[serde(rename = "NoCheckDest")]
5506        pub no_check_dest: bool,
5507        #[serde(rename = "NoConsole")]
5508        pub no_console: bool,
5509        #[serde(rename = "NoGzip")]
5510        pub no_gzip: bool,
5511        #[serde(rename = "NoTraverse")]
5512        pub no_traverse: bool,
5513        #[serde(rename = "NoUnicodeNormalization")]
5514        pub no_unicode_normalization: bool,
5515        #[serde(rename = "NoUpdateDirModTime")]
5516        pub no_update_dir_mod_time: bool,
5517        #[serde(rename = "NoUpdateModTime")]
5518        pub no_update_mod_time: bool,
5519        #[serde(rename = "OrderBy")]
5520        pub order_by: ::std::string::String,
5521        #[serde(rename = "PartialSuffix")]
5522        pub partial_suffix: ::std::string::String,
5523        #[serde(rename = "PasswordCommand")]
5524        pub password_command: ::std::option::Option<::std::string::String>,
5525        #[serde(rename = "Progress")]
5526        pub progress: bool,
5527        #[serde(rename = "ProgressTerminalTitle")]
5528        pub progress_terminal_title: bool,
5529        #[serde(rename = "RefreshTimes")]
5530        pub refresh_times: bool,
5531        #[serde(rename = "Retries")]
5532        pub retries: f64,
5533        #[serde(rename = "RetriesInterval")]
5534        pub retries_interval: f64,
5535        #[serde(rename = "ServerSideAcrossConfigs")]
5536        pub server_side_across_configs: bool,
5537        #[serde(rename = "SizeOnly")]
5538        pub size_only: bool,
5539        #[serde(rename = "StatsFileNameLength")]
5540        pub stats_file_name_length: f64,
5541        #[serde(rename = "StatsLogLevel")]
5542        pub stats_log_level: ::std::string::String,
5543        #[serde(rename = "StatsOneLine")]
5544        pub stats_one_line: bool,
5545        #[serde(rename = "StatsOneLineDate")]
5546        pub stats_one_line_date: bool,
5547        #[serde(rename = "StatsOneLineDateFormat")]
5548        pub stats_one_line_date_format: ::std::string::String,
5549        #[serde(rename = "StreamingUploadCutoff")]
5550        pub streaming_upload_cutoff: f64,
5551        #[serde(rename = "Suffix")]
5552        pub suffix: ::std::string::String,
5553        #[serde(rename = "SuffixKeepExtension")]
5554        pub suffix_keep_extension: bool,
5555        #[serde(rename = "TerminalColorMode")]
5556        pub terminal_color_mode: ::std::string::String,
5557        #[serde(rename = "Timeout")]
5558        pub timeout: f64,
5559        #[serde(rename = "TPSLimit")]
5560        pub tps_limit: f64,
5561        #[serde(rename = "TPSLimitBurst")]
5562        pub tps_limit_burst: f64,
5563        #[serde(rename = "TrackRenames")]
5564        pub track_renames: bool,
5565        #[serde(rename = "TrackRenamesStrategy")]
5566        pub track_renames_strategy: ::std::string::String,
5567        #[serde(rename = "TrafficClass")]
5568        pub traffic_class: f64,
5569        #[serde(rename = "Transfers")]
5570        pub transfers: f64,
5571        #[serde(rename = "UpdateOlder")]
5572        pub update_older: bool,
5573        #[serde(rename = "UploadHeaders")]
5574        pub upload_headers: ::std::option::Option<::std::string::String>,
5575        #[serde(rename = "UseJSONLog")]
5576        pub use_json_log: bool,
5577        #[serde(rename = "UseListR")]
5578        pub use_list_r: bool,
5579        #[serde(rename = "UseMmap")]
5580        pub use_mmap: bool,
5581        #[serde(rename = "UseServerModTime")]
5582        pub use_server_mod_time: bool,
5583        #[serde(rename = "UserAgent")]
5584        pub user_agent: ::std::string::String,
5585    }
5586
5587    impl ::std::convert::From<&OptionsLocalResponseConfig> for OptionsLocalResponseConfig {
5588        fn from(value: &OptionsLocalResponseConfig) -> Self {
5589            value.clone()
5590        }
5591    }
5592
5593    ///`OptionsLocalResponseFilter`
5594    ///
5595    /// <details><summary>JSON schema</summary>
5596    ///
5597    /// ```json
5598    ///{
5599    ///  "type": "object",
5600    ///  "required": [
5601    ///    "DeleteExcluded",
5602    ///    "ExcludeFile",
5603    ///    "ExcludeFrom",
5604    ///    "ExcludeRule",
5605    ///    "FilesFrom",
5606    ///    "FilesFromRaw",
5607    ///    "FilterFrom",
5608    ///    "FilterRule",
5609    ///    "HashFilter",
5610    ///    "IgnoreCase",
5611    ///    "IncludeFrom",
5612    ///    "IncludeRule",
5613    ///    "MaxAge",
5614    ///    "MaxSize",
5615    ///    "MetaRules",
5616    ///    "MinAge",
5617    ///    "MinSize"
5618    ///  ],
5619    ///  "properties": {
5620    ///    "DeleteExcluded": {
5621    ///      "type": "boolean"
5622    ///    },
5623    ///    "ExcludeFile": {
5624    ///      "type": "array",
5625    ///      "items": {
5626    ///        "type": "string"
5627    ///      }
5628    ///    },
5629    ///    "ExcludeFrom": {
5630    ///      "type": "array",
5631    ///      "items": {
5632    ///        "type": "string"
5633    ///      }
5634    ///    },
5635    ///    "ExcludeRule": {
5636    ///      "type": "array",
5637    ///      "items": {
5638    ///        "type": "string"
5639    ///      }
5640    ///    },
5641    ///    "FilesFrom": {
5642    ///      "type": "array",
5643    ///      "items": {
5644    ///        "type": "string"
5645    ///      }
5646    ///    },
5647    ///    "FilesFromRaw": {
5648    ///      "type": "array",
5649    ///      "items": {
5650    ///        "type": "string"
5651    ///      }
5652    ///    },
5653    ///    "FilterFrom": {
5654    ///      "type": "array",
5655    ///      "items": {
5656    ///        "type": "string"
5657    ///      }
5658    ///    },
5659    ///    "FilterRule": {
5660    ///      "type": "array",
5661    ///      "items": {
5662    ///        "type": "string"
5663    ///      }
5664    ///    },
5665    ///    "HashFilter": {
5666    ///      "type": "string"
5667    ///    },
5668    ///    "IgnoreCase": {
5669    ///      "type": "boolean"
5670    ///    },
5671    ///    "IncludeFrom": {
5672    ///      "type": "array",
5673    ///      "items": {
5674    ///        "type": "string"
5675    ///      }
5676    ///    },
5677    ///    "IncludeRule": {
5678    ///      "type": "array",
5679    ///      "items": {
5680    ///        "type": "string"
5681    ///      }
5682    ///    },
5683    ///    "MaxAge": {
5684    ///      "type": "number"
5685    ///    },
5686    ///    "MaxSize": {
5687    ///      "type": "number"
5688    ///    },
5689    ///    "MetaRules": {
5690    ///      "type": "object",
5691    ///      "required": [
5692    ///        "ExcludeFrom",
5693    ///        "ExcludeRule",
5694    ///        "FilterFrom",
5695    ///        "FilterRule",
5696    ///        "IncludeFrom",
5697    ///        "IncludeRule"
5698    ///      ],
5699    ///      "properties": {
5700    ///        "ExcludeFrom": {
5701    ///          "type": "array",
5702    ///          "items": {
5703    ///            "type": "string"
5704    ///          }
5705    ///        },
5706    ///        "ExcludeRule": {
5707    ///          "type": "array",
5708    ///          "items": {
5709    ///            "type": "string"
5710    ///          }
5711    ///        },
5712    ///        "FilterFrom": {
5713    ///          "type": "array",
5714    ///          "items": {
5715    ///            "type": "string"
5716    ///          }
5717    ///        },
5718    ///        "FilterRule": {
5719    ///          "type": "array",
5720    ///          "items": {
5721    ///            "type": "string"
5722    ///          }
5723    ///        },
5724    ///        "IncludeFrom": {
5725    ///          "type": "array",
5726    ///          "items": {
5727    ///            "type": "string"
5728    ///          }
5729    ///        },
5730    ///        "IncludeRule": {
5731    ///          "type": "array",
5732    ///          "items": {
5733    ///            "type": "string"
5734    ///          }
5735    ///        }
5736    ///      }
5737    ///    },
5738    ///    "MinAge": {
5739    ///      "type": "number"
5740    ///    },
5741    ///    "MinSize": {
5742    ///      "type": "number"
5743    ///    }
5744    ///  }
5745    ///}
5746    /// ```
5747    /// </details>
5748    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5749    pub struct OptionsLocalResponseFilter {
5750        #[serde(rename = "DeleteExcluded")]
5751        pub delete_excluded: bool,
5752        #[serde(rename = "ExcludeFile")]
5753        pub exclude_file: ::std::vec::Vec<::std::string::String>,
5754        #[serde(rename = "ExcludeFrom")]
5755        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5756        #[serde(rename = "ExcludeRule")]
5757        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5758        #[serde(rename = "FilesFrom")]
5759        pub files_from: ::std::vec::Vec<::std::string::String>,
5760        #[serde(rename = "FilesFromRaw")]
5761        pub files_from_raw: ::std::vec::Vec<::std::string::String>,
5762        #[serde(rename = "FilterFrom")]
5763        pub filter_from: ::std::vec::Vec<::std::string::String>,
5764        #[serde(rename = "FilterRule")]
5765        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5766        #[serde(rename = "HashFilter")]
5767        pub hash_filter: ::std::string::String,
5768        #[serde(rename = "IgnoreCase")]
5769        pub ignore_case: bool,
5770        #[serde(rename = "IncludeFrom")]
5771        pub include_from: ::std::vec::Vec<::std::string::String>,
5772        #[serde(rename = "IncludeRule")]
5773        pub include_rule: ::std::vec::Vec<::std::string::String>,
5774        #[serde(rename = "MaxAge")]
5775        pub max_age: f64,
5776        #[serde(rename = "MaxSize")]
5777        pub max_size: f64,
5778        #[serde(rename = "MetaRules")]
5779        pub meta_rules: OptionsLocalResponseFilterMetaRules,
5780        #[serde(rename = "MinAge")]
5781        pub min_age: f64,
5782        #[serde(rename = "MinSize")]
5783        pub min_size: f64,
5784    }
5785
5786    impl ::std::convert::From<&OptionsLocalResponseFilter> for OptionsLocalResponseFilter {
5787        fn from(value: &OptionsLocalResponseFilter) -> Self {
5788            value.clone()
5789        }
5790    }
5791
5792    ///`OptionsLocalResponseFilterMetaRules`
5793    ///
5794    /// <details><summary>JSON schema</summary>
5795    ///
5796    /// ```json
5797    ///{
5798    ///  "type": "object",
5799    ///  "required": [
5800    ///    "ExcludeFrom",
5801    ///    "ExcludeRule",
5802    ///    "FilterFrom",
5803    ///    "FilterRule",
5804    ///    "IncludeFrom",
5805    ///    "IncludeRule"
5806    ///  ],
5807    ///  "properties": {
5808    ///    "ExcludeFrom": {
5809    ///      "type": "array",
5810    ///      "items": {
5811    ///        "type": "string"
5812    ///      }
5813    ///    },
5814    ///    "ExcludeRule": {
5815    ///      "type": "array",
5816    ///      "items": {
5817    ///        "type": "string"
5818    ///      }
5819    ///    },
5820    ///    "FilterFrom": {
5821    ///      "type": "array",
5822    ///      "items": {
5823    ///        "type": "string"
5824    ///      }
5825    ///    },
5826    ///    "FilterRule": {
5827    ///      "type": "array",
5828    ///      "items": {
5829    ///        "type": "string"
5830    ///      }
5831    ///    },
5832    ///    "IncludeFrom": {
5833    ///      "type": "array",
5834    ///      "items": {
5835    ///        "type": "string"
5836    ///      }
5837    ///    },
5838    ///    "IncludeRule": {
5839    ///      "type": "array",
5840    ///      "items": {
5841    ///        "type": "string"
5842    ///      }
5843    ///    }
5844    ///  }
5845    ///}
5846    /// ```
5847    /// </details>
5848    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5849    pub struct OptionsLocalResponseFilterMetaRules {
5850        #[serde(rename = "ExcludeFrom")]
5851        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5852        #[serde(rename = "ExcludeRule")]
5853        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5854        #[serde(rename = "FilterFrom")]
5855        pub filter_from: ::std::vec::Vec<::std::string::String>,
5856        #[serde(rename = "FilterRule")]
5857        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5858        #[serde(rename = "IncludeFrom")]
5859        pub include_from: ::std::vec::Vec<::std::string::String>,
5860        #[serde(rename = "IncludeRule")]
5861        pub include_rule: ::std::vec::Vec<::std::string::String>,
5862    }
5863
5864    impl ::std::convert::From<&OptionsLocalResponseFilterMetaRules>
5865        for OptionsLocalResponseFilterMetaRules
5866    {
5867        fn from(value: &OptionsLocalResponseFilterMetaRules) -> Self {
5868            value.clone()
5869        }
5870    }
5871
5872    ///`OptionsSetDlnaValue`
5873    ///
5874    /// <details><summary>JSON schema</summary>
5875    ///
5876    /// ```json
5877    ///{
5878    ///  "oneOf": [
5879    ///    {
5880    ///      "type": "string"
5881    ///    },
5882    ///    {
5883    ///      "type": "number"
5884    ///    },
5885    ///    {
5886    ///      "type": "integer"
5887    ///    },
5888    ///    {
5889    ///      "type": "boolean"
5890    ///    },
5891    ///    {
5892    ///      "type": "array",
5893    ///      "items": {}
5894    ///    },
5895    ///    {
5896    ///      "type": "object",
5897    ///      "additionalProperties": {}
5898    ///    }
5899    ///  ]
5900    ///}
5901    /// ```
5902    /// </details>
5903    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5904    #[serde(untagged)]
5905    pub enum OptionsSetDlnaValue {
5906        Variant0(::std::string::String),
5907        Variant1(f64),
5908        Variant2(i64),
5909        Variant3(bool),
5910        Variant4(::std::vec::Vec<::serde_json::Value>),
5911        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5912    }
5913
5914    impl ::std::convert::From<&Self> for OptionsSetDlnaValue {
5915        fn from(value: &OptionsSetDlnaValue) -> Self {
5916            value.clone()
5917        }
5918    }
5919
5920    impl ::std::convert::From<f64> for OptionsSetDlnaValue {
5921        fn from(value: f64) -> Self {
5922            Self::Variant1(value)
5923        }
5924    }
5925
5926    impl ::std::convert::From<i64> for OptionsSetDlnaValue {
5927        fn from(value: i64) -> Self {
5928            Self::Variant2(value)
5929        }
5930    }
5931
5932    impl ::std::convert::From<bool> for OptionsSetDlnaValue {
5933        fn from(value: bool) -> Self {
5934            Self::Variant3(value)
5935        }
5936    }
5937
5938    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetDlnaValue {
5939        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5940            Self::Variant4(value)
5941        }
5942    }
5943
5944    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5945        for OptionsSetDlnaValue
5946    {
5947        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5948            Self::Variant5(value)
5949        }
5950    }
5951
5952    ///`OptionsSetFilterValue`
5953    ///
5954    /// <details><summary>JSON schema</summary>
5955    ///
5956    /// ```json
5957    ///{
5958    ///  "oneOf": [
5959    ///    {
5960    ///      "type": "string"
5961    ///    },
5962    ///    {
5963    ///      "type": "number"
5964    ///    },
5965    ///    {
5966    ///      "type": "integer"
5967    ///    },
5968    ///    {
5969    ///      "type": "boolean"
5970    ///    },
5971    ///    {
5972    ///      "type": "array",
5973    ///      "items": {}
5974    ///    },
5975    ///    {
5976    ///      "type": "object",
5977    ///      "additionalProperties": {}
5978    ///    }
5979    ///  ]
5980    ///}
5981    /// ```
5982    /// </details>
5983    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5984    #[serde(untagged)]
5985    pub enum OptionsSetFilterValue {
5986        Variant0(::std::string::String),
5987        Variant1(f64),
5988        Variant2(i64),
5989        Variant3(bool),
5990        Variant4(::std::vec::Vec<::serde_json::Value>),
5991        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5992    }
5993
5994    impl ::std::convert::From<&Self> for OptionsSetFilterValue {
5995        fn from(value: &OptionsSetFilterValue) -> Self {
5996            value.clone()
5997        }
5998    }
5999
6000    impl ::std::convert::From<f64> for OptionsSetFilterValue {
6001        fn from(value: f64) -> Self {
6002            Self::Variant1(value)
6003        }
6004    }
6005
6006    impl ::std::convert::From<i64> for OptionsSetFilterValue {
6007        fn from(value: i64) -> Self {
6008            Self::Variant2(value)
6009        }
6010    }
6011
6012    impl ::std::convert::From<bool> for OptionsSetFilterValue {
6013        fn from(value: bool) -> Self {
6014            Self::Variant3(value)
6015        }
6016    }
6017
6018    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFilterValue {
6019        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6020            Self::Variant4(value)
6021        }
6022    }
6023
6024    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6025        for OptionsSetFilterValue
6026    {
6027        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6028            Self::Variant5(value)
6029        }
6030    }
6031
6032    ///`OptionsSetFtpValue`
6033    ///
6034    /// <details><summary>JSON schema</summary>
6035    ///
6036    /// ```json
6037    ///{
6038    ///  "oneOf": [
6039    ///    {
6040    ///      "type": "string"
6041    ///    },
6042    ///    {
6043    ///      "type": "number"
6044    ///    },
6045    ///    {
6046    ///      "type": "integer"
6047    ///    },
6048    ///    {
6049    ///      "type": "boolean"
6050    ///    },
6051    ///    {
6052    ///      "type": "array",
6053    ///      "items": {}
6054    ///    },
6055    ///    {
6056    ///      "type": "object",
6057    ///      "additionalProperties": {}
6058    ///    }
6059    ///  ]
6060    ///}
6061    /// ```
6062    /// </details>
6063    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6064    #[serde(untagged)]
6065    pub enum OptionsSetFtpValue {
6066        Variant0(::std::string::String),
6067        Variant1(f64),
6068        Variant2(i64),
6069        Variant3(bool),
6070        Variant4(::std::vec::Vec<::serde_json::Value>),
6071        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6072    }
6073
6074    impl ::std::convert::From<&Self> for OptionsSetFtpValue {
6075        fn from(value: &OptionsSetFtpValue) -> Self {
6076            value.clone()
6077        }
6078    }
6079
6080    impl ::std::convert::From<f64> for OptionsSetFtpValue {
6081        fn from(value: f64) -> Self {
6082            Self::Variant1(value)
6083        }
6084    }
6085
6086    impl ::std::convert::From<i64> for OptionsSetFtpValue {
6087        fn from(value: i64) -> Self {
6088            Self::Variant2(value)
6089        }
6090    }
6091
6092    impl ::std::convert::From<bool> for OptionsSetFtpValue {
6093        fn from(value: bool) -> Self {
6094            Self::Variant3(value)
6095        }
6096    }
6097
6098    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFtpValue {
6099        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6100            Self::Variant4(value)
6101        }
6102    }
6103
6104    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6105        for OptionsSetFtpValue
6106    {
6107        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6108            Self::Variant5(value)
6109        }
6110    }
6111
6112    ///`OptionsSetHttpValue`
6113    ///
6114    /// <details><summary>JSON schema</summary>
6115    ///
6116    /// ```json
6117    ///{
6118    ///  "oneOf": [
6119    ///    {
6120    ///      "type": "string"
6121    ///    },
6122    ///    {
6123    ///      "type": "number"
6124    ///    },
6125    ///    {
6126    ///      "type": "integer"
6127    ///    },
6128    ///    {
6129    ///      "type": "boolean"
6130    ///    },
6131    ///    {
6132    ///      "type": "array",
6133    ///      "items": {}
6134    ///    },
6135    ///    {
6136    ///      "type": "object",
6137    ///      "additionalProperties": {}
6138    ///    }
6139    ///  ]
6140    ///}
6141    /// ```
6142    /// </details>
6143    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6144    #[serde(untagged)]
6145    pub enum OptionsSetHttpValue {
6146        Variant0(::std::string::String),
6147        Variant1(f64),
6148        Variant2(i64),
6149        Variant3(bool),
6150        Variant4(::std::vec::Vec<::serde_json::Value>),
6151        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6152    }
6153
6154    impl ::std::convert::From<&Self> for OptionsSetHttpValue {
6155        fn from(value: &OptionsSetHttpValue) -> Self {
6156            value.clone()
6157        }
6158    }
6159
6160    impl ::std::convert::From<f64> for OptionsSetHttpValue {
6161        fn from(value: f64) -> Self {
6162            Self::Variant1(value)
6163        }
6164    }
6165
6166    impl ::std::convert::From<i64> for OptionsSetHttpValue {
6167        fn from(value: i64) -> Self {
6168            Self::Variant2(value)
6169        }
6170    }
6171
6172    impl ::std::convert::From<bool> for OptionsSetHttpValue {
6173        fn from(value: bool) -> Self {
6174            Self::Variant3(value)
6175        }
6176    }
6177
6178    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetHttpValue {
6179        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6180            Self::Variant4(value)
6181        }
6182    }
6183
6184    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6185        for OptionsSetHttpValue
6186    {
6187        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6188            Self::Variant5(value)
6189        }
6190    }
6191
6192    ///`OptionsSetLogValue`
6193    ///
6194    /// <details><summary>JSON schema</summary>
6195    ///
6196    /// ```json
6197    ///{
6198    ///  "oneOf": [
6199    ///    {
6200    ///      "type": "string"
6201    ///    },
6202    ///    {
6203    ///      "type": "number"
6204    ///    },
6205    ///    {
6206    ///      "type": "integer"
6207    ///    },
6208    ///    {
6209    ///      "type": "boolean"
6210    ///    },
6211    ///    {
6212    ///      "type": "array",
6213    ///      "items": {}
6214    ///    },
6215    ///    {
6216    ///      "type": "object",
6217    ///      "additionalProperties": {}
6218    ///    }
6219    ///  ]
6220    ///}
6221    /// ```
6222    /// </details>
6223    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6224    #[serde(untagged)]
6225    pub enum OptionsSetLogValue {
6226        Variant0(::std::string::String),
6227        Variant1(f64),
6228        Variant2(i64),
6229        Variant3(bool),
6230        Variant4(::std::vec::Vec<::serde_json::Value>),
6231        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6232    }
6233
6234    impl ::std::convert::From<&Self> for OptionsSetLogValue {
6235        fn from(value: &OptionsSetLogValue) -> Self {
6236            value.clone()
6237        }
6238    }
6239
6240    impl ::std::convert::From<f64> for OptionsSetLogValue {
6241        fn from(value: f64) -> Self {
6242            Self::Variant1(value)
6243        }
6244    }
6245
6246    impl ::std::convert::From<i64> for OptionsSetLogValue {
6247        fn from(value: i64) -> Self {
6248            Self::Variant2(value)
6249        }
6250    }
6251
6252    impl ::std::convert::From<bool> for OptionsSetLogValue {
6253        fn from(value: bool) -> Self {
6254            Self::Variant3(value)
6255        }
6256    }
6257
6258    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetLogValue {
6259        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6260            Self::Variant4(value)
6261        }
6262    }
6263
6264    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6265        for OptionsSetLogValue
6266    {
6267        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6268            Self::Variant5(value)
6269        }
6270    }
6271
6272    ///`OptionsSetMainValue`
6273    ///
6274    /// <details><summary>JSON schema</summary>
6275    ///
6276    /// ```json
6277    ///{
6278    ///  "oneOf": [
6279    ///    {
6280    ///      "type": "string"
6281    ///    },
6282    ///    {
6283    ///      "type": "number"
6284    ///    },
6285    ///    {
6286    ///      "type": "integer"
6287    ///    },
6288    ///    {
6289    ///      "type": "boolean"
6290    ///    },
6291    ///    {
6292    ///      "type": "array",
6293    ///      "items": {}
6294    ///    },
6295    ///    {
6296    ///      "type": "object",
6297    ///      "additionalProperties": {}
6298    ///    }
6299    ///  ]
6300    ///}
6301    /// ```
6302    /// </details>
6303    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6304    #[serde(untagged)]
6305    pub enum OptionsSetMainValue {
6306        Variant0(::std::string::String),
6307        Variant1(f64),
6308        Variant2(i64),
6309        Variant3(bool),
6310        Variant4(::std::vec::Vec<::serde_json::Value>),
6311        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6312    }
6313
6314    impl ::std::convert::From<&Self> for OptionsSetMainValue {
6315        fn from(value: &OptionsSetMainValue) -> Self {
6316            value.clone()
6317        }
6318    }
6319
6320    impl ::std::convert::From<f64> for OptionsSetMainValue {
6321        fn from(value: f64) -> Self {
6322            Self::Variant1(value)
6323        }
6324    }
6325
6326    impl ::std::convert::From<i64> for OptionsSetMainValue {
6327        fn from(value: i64) -> Self {
6328            Self::Variant2(value)
6329        }
6330    }
6331
6332    impl ::std::convert::From<bool> for OptionsSetMainValue {
6333        fn from(value: bool) -> Self {
6334            Self::Variant3(value)
6335        }
6336    }
6337
6338    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMainValue {
6339        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6340            Self::Variant4(value)
6341        }
6342    }
6343
6344    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6345        for OptionsSetMainValue
6346    {
6347        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6348            Self::Variant5(value)
6349        }
6350    }
6351
6352    ///`OptionsSetMountValue`
6353    ///
6354    /// <details><summary>JSON schema</summary>
6355    ///
6356    /// ```json
6357    ///{
6358    ///  "oneOf": [
6359    ///    {
6360    ///      "type": "string"
6361    ///    },
6362    ///    {
6363    ///      "type": "number"
6364    ///    },
6365    ///    {
6366    ///      "type": "integer"
6367    ///    },
6368    ///    {
6369    ///      "type": "boolean"
6370    ///    },
6371    ///    {
6372    ///      "type": "array",
6373    ///      "items": {}
6374    ///    },
6375    ///    {
6376    ///      "type": "object",
6377    ///      "additionalProperties": {}
6378    ///    }
6379    ///  ]
6380    ///}
6381    /// ```
6382    /// </details>
6383    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6384    #[serde(untagged)]
6385    pub enum OptionsSetMountValue {
6386        Variant0(::std::string::String),
6387        Variant1(f64),
6388        Variant2(i64),
6389        Variant3(bool),
6390        Variant4(::std::vec::Vec<::serde_json::Value>),
6391        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6392    }
6393
6394    impl ::std::convert::From<&Self> for OptionsSetMountValue {
6395        fn from(value: &OptionsSetMountValue) -> Self {
6396            value.clone()
6397        }
6398    }
6399
6400    impl ::std::convert::From<f64> for OptionsSetMountValue {
6401        fn from(value: f64) -> Self {
6402            Self::Variant1(value)
6403        }
6404    }
6405
6406    impl ::std::convert::From<i64> for OptionsSetMountValue {
6407        fn from(value: i64) -> Self {
6408            Self::Variant2(value)
6409        }
6410    }
6411
6412    impl ::std::convert::From<bool> for OptionsSetMountValue {
6413        fn from(value: bool) -> Self {
6414            Self::Variant3(value)
6415        }
6416    }
6417
6418    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMountValue {
6419        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6420            Self::Variant4(value)
6421        }
6422    }
6423
6424    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6425        for OptionsSetMountValue
6426    {
6427        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6428            Self::Variant5(value)
6429        }
6430    }
6431
6432    ///`OptionsSetNfsValue`
6433    ///
6434    /// <details><summary>JSON schema</summary>
6435    ///
6436    /// ```json
6437    ///{
6438    ///  "oneOf": [
6439    ///    {
6440    ///      "type": "string"
6441    ///    },
6442    ///    {
6443    ///      "type": "number"
6444    ///    },
6445    ///    {
6446    ///      "type": "integer"
6447    ///    },
6448    ///    {
6449    ///      "type": "boolean"
6450    ///    },
6451    ///    {
6452    ///      "type": "array",
6453    ///      "items": {}
6454    ///    },
6455    ///    {
6456    ///      "type": "object",
6457    ///      "additionalProperties": {}
6458    ///    }
6459    ///  ]
6460    ///}
6461    /// ```
6462    /// </details>
6463    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6464    #[serde(untagged)]
6465    pub enum OptionsSetNfsValue {
6466        Variant0(::std::string::String),
6467        Variant1(f64),
6468        Variant2(i64),
6469        Variant3(bool),
6470        Variant4(::std::vec::Vec<::serde_json::Value>),
6471        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6472    }
6473
6474    impl ::std::convert::From<&Self> for OptionsSetNfsValue {
6475        fn from(value: &OptionsSetNfsValue) -> Self {
6476            value.clone()
6477        }
6478    }
6479
6480    impl ::std::convert::From<f64> for OptionsSetNfsValue {
6481        fn from(value: f64) -> Self {
6482            Self::Variant1(value)
6483        }
6484    }
6485
6486    impl ::std::convert::From<i64> for OptionsSetNfsValue {
6487        fn from(value: i64) -> Self {
6488            Self::Variant2(value)
6489        }
6490    }
6491
6492    impl ::std::convert::From<bool> for OptionsSetNfsValue {
6493        fn from(value: bool) -> Self {
6494            Self::Variant3(value)
6495        }
6496    }
6497
6498    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetNfsValue {
6499        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6500            Self::Variant4(value)
6501        }
6502    }
6503
6504    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6505        for OptionsSetNfsValue
6506    {
6507        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6508            Self::Variant5(value)
6509        }
6510    }
6511
6512    ///`OptionsSetProxyValue`
6513    ///
6514    /// <details><summary>JSON schema</summary>
6515    ///
6516    /// ```json
6517    ///{
6518    ///  "oneOf": [
6519    ///    {
6520    ///      "type": "string"
6521    ///    },
6522    ///    {
6523    ///      "type": "number"
6524    ///    },
6525    ///    {
6526    ///      "type": "integer"
6527    ///    },
6528    ///    {
6529    ///      "type": "boolean"
6530    ///    },
6531    ///    {
6532    ///      "type": "array",
6533    ///      "items": {}
6534    ///    },
6535    ///    {
6536    ///      "type": "object",
6537    ///      "additionalProperties": {}
6538    ///    }
6539    ///  ]
6540    ///}
6541    /// ```
6542    /// </details>
6543    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6544    #[serde(untagged)]
6545    pub enum OptionsSetProxyValue {
6546        Variant0(::std::string::String),
6547        Variant1(f64),
6548        Variant2(i64),
6549        Variant3(bool),
6550        Variant4(::std::vec::Vec<::serde_json::Value>),
6551        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6552    }
6553
6554    impl ::std::convert::From<&Self> for OptionsSetProxyValue {
6555        fn from(value: &OptionsSetProxyValue) -> Self {
6556            value.clone()
6557        }
6558    }
6559
6560    impl ::std::convert::From<f64> for OptionsSetProxyValue {
6561        fn from(value: f64) -> Self {
6562            Self::Variant1(value)
6563        }
6564    }
6565
6566    impl ::std::convert::From<i64> for OptionsSetProxyValue {
6567        fn from(value: i64) -> Self {
6568            Self::Variant2(value)
6569        }
6570    }
6571
6572    impl ::std::convert::From<bool> for OptionsSetProxyValue {
6573        fn from(value: bool) -> Self {
6574            Self::Variant3(value)
6575        }
6576    }
6577
6578    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetProxyValue {
6579        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6580            Self::Variant4(value)
6581        }
6582    }
6583
6584    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6585        for OptionsSetProxyValue
6586    {
6587        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6588            Self::Variant5(value)
6589        }
6590    }
6591
6592    ///`OptionsSetRcValue`
6593    ///
6594    /// <details><summary>JSON schema</summary>
6595    ///
6596    /// ```json
6597    ///{
6598    ///  "oneOf": [
6599    ///    {
6600    ///      "type": "string"
6601    ///    },
6602    ///    {
6603    ///      "type": "number"
6604    ///    },
6605    ///    {
6606    ///      "type": "integer"
6607    ///    },
6608    ///    {
6609    ///      "type": "boolean"
6610    ///    },
6611    ///    {
6612    ///      "type": "array",
6613    ///      "items": {}
6614    ///    },
6615    ///    {
6616    ///      "type": "object",
6617    ///      "additionalProperties": {}
6618    ///    }
6619    ///  ]
6620    ///}
6621    /// ```
6622    /// </details>
6623    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6624    #[serde(untagged)]
6625    pub enum OptionsSetRcValue {
6626        Variant0(::std::string::String),
6627        Variant1(f64),
6628        Variant2(i64),
6629        Variant3(bool),
6630        Variant4(::std::vec::Vec<::serde_json::Value>),
6631        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6632    }
6633
6634    impl ::std::convert::From<&Self> for OptionsSetRcValue {
6635        fn from(value: &OptionsSetRcValue) -> Self {
6636            value.clone()
6637        }
6638    }
6639
6640    impl ::std::convert::From<f64> for OptionsSetRcValue {
6641        fn from(value: f64) -> Self {
6642            Self::Variant1(value)
6643        }
6644    }
6645
6646    impl ::std::convert::From<i64> for OptionsSetRcValue {
6647        fn from(value: i64) -> Self {
6648            Self::Variant2(value)
6649        }
6650    }
6651
6652    impl ::std::convert::From<bool> for OptionsSetRcValue {
6653        fn from(value: bool) -> Self {
6654            Self::Variant3(value)
6655        }
6656    }
6657
6658    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetRcValue {
6659        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6660            Self::Variant4(value)
6661        }
6662    }
6663
6664    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6665        for OptionsSetRcValue
6666    {
6667        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6668            Self::Variant5(value)
6669        }
6670    }
6671
6672    ///`OptionsSetResticValue`
6673    ///
6674    /// <details><summary>JSON schema</summary>
6675    ///
6676    /// ```json
6677    ///{
6678    ///  "oneOf": [
6679    ///    {
6680    ///      "type": "string"
6681    ///    },
6682    ///    {
6683    ///      "type": "number"
6684    ///    },
6685    ///    {
6686    ///      "type": "integer"
6687    ///    },
6688    ///    {
6689    ///      "type": "boolean"
6690    ///    },
6691    ///    {
6692    ///      "type": "array",
6693    ///      "items": {}
6694    ///    },
6695    ///    {
6696    ///      "type": "object",
6697    ///      "additionalProperties": {}
6698    ///    }
6699    ///  ]
6700    ///}
6701    /// ```
6702    /// </details>
6703    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6704    #[serde(untagged)]
6705    pub enum OptionsSetResticValue {
6706        Variant0(::std::string::String),
6707        Variant1(f64),
6708        Variant2(i64),
6709        Variant3(bool),
6710        Variant4(::std::vec::Vec<::serde_json::Value>),
6711        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6712    }
6713
6714    impl ::std::convert::From<&Self> for OptionsSetResticValue {
6715        fn from(value: &OptionsSetResticValue) -> Self {
6716            value.clone()
6717        }
6718    }
6719
6720    impl ::std::convert::From<f64> for OptionsSetResticValue {
6721        fn from(value: f64) -> Self {
6722            Self::Variant1(value)
6723        }
6724    }
6725
6726    impl ::std::convert::From<i64> for OptionsSetResticValue {
6727        fn from(value: i64) -> Self {
6728            Self::Variant2(value)
6729        }
6730    }
6731
6732    impl ::std::convert::From<bool> for OptionsSetResticValue {
6733        fn from(value: bool) -> Self {
6734            Self::Variant3(value)
6735        }
6736    }
6737
6738    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetResticValue {
6739        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6740            Self::Variant4(value)
6741        }
6742    }
6743
6744    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6745        for OptionsSetResticValue
6746    {
6747        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6748            Self::Variant5(value)
6749        }
6750    }
6751
6752    ///`OptionsSetS3Value`
6753    ///
6754    /// <details><summary>JSON schema</summary>
6755    ///
6756    /// ```json
6757    ///{
6758    ///  "oneOf": [
6759    ///    {
6760    ///      "type": "string"
6761    ///    },
6762    ///    {
6763    ///      "type": "number"
6764    ///    },
6765    ///    {
6766    ///      "type": "integer"
6767    ///    },
6768    ///    {
6769    ///      "type": "boolean"
6770    ///    },
6771    ///    {
6772    ///      "type": "array",
6773    ///      "items": {}
6774    ///    },
6775    ///    {
6776    ///      "type": "object",
6777    ///      "additionalProperties": {}
6778    ///    }
6779    ///  ]
6780    ///}
6781    /// ```
6782    /// </details>
6783    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6784    #[serde(untagged)]
6785    pub enum OptionsSetS3Value {
6786        Variant0(::std::string::String),
6787        Variant1(f64),
6788        Variant2(i64),
6789        Variant3(bool),
6790        Variant4(::std::vec::Vec<::serde_json::Value>),
6791        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6792    }
6793
6794    impl ::std::convert::From<&Self> for OptionsSetS3Value {
6795        fn from(value: &OptionsSetS3Value) -> Self {
6796            value.clone()
6797        }
6798    }
6799
6800    impl ::std::convert::From<f64> for OptionsSetS3Value {
6801        fn from(value: f64) -> Self {
6802            Self::Variant1(value)
6803        }
6804    }
6805
6806    impl ::std::convert::From<i64> for OptionsSetS3Value {
6807        fn from(value: i64) -> Self {
6808            Self::Variant2(value)
6809        }
6810    }
6811
6812    impl ::std::convert::From<bool> for OptionsSetS3Value {
6813        fn from(value: bool) -> Self {
6814            Self::Variant3(value)
6815        }
6816    }
6817
6818    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetS3Value {
6819        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6820            Self::Variant4(value)
6821        }
6822    }
6823
6824    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6825        for OptionsSetS3Value
6826    {
6827        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6828            Self::Variant5(value)
6829        }
6830    }
6831
6832    ///`OptionsSetSftpValue`
6833    ///
6834    /// <details><summary>JSON schema</summary>
6835    ///
6836    /// ```json
6837    ///{
6838    ///  "oneOf": [
6839    ///    {
6840    ///      "type": "string"
6841    ///    },
6842    ///    {
6843    ///      "type": "number"
6844    ///    },
6845    ///    {
6846    ///      "type": "integer"
6847    ///    },
6848    ///    {
6849    ///      "type": "boolean"
6850    ///    },
6851    ///    {
6852    ///      "type": "array",
6853    ///      "items": {}
6854    ///    },
6855    ///    {
6856    ///      "type": "object",
6857    ///      "additionalProperties": {}
6858    ///    }
6859    ///  ]
6860    ///}
6861    /// ```
6862    /// </details>
6863    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6864    #[serde(untagged)]
6865    pub enum OptionsSetSftpValue {
6866        Variant0(::std::string::String),
6867        Variant1(f64),
6868        Variant2(i64),
6869        Variant3(bool),
6870        Variant4(::std::vec::Vec<::serde_json::Value>),
6871        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6872    }
6873
6874    impl ::std::convert::From<&Self> for OptionsSetSftpValue {
6875        fn from(value: &OptionsSetSftpValue) -> Self {
6876            value.clone()
6877        }
6878    }
6879
6880    impl ::std::convert::From<f64> for OptionsSetSftpValue {
6881        fn from(value: f64) -> Self {
6882            Self::Variant1(value)
6883        }
6884    }
6885
6886    impl ::std::convert::From<i64> for OptionsSetSftpValue {
6887        fn from(value: i64) -> Self {
6888            Self::Variant2(value)
6889        }
6890    }
6891
6892    impl ::std::convert::From<bool> for OptionsSetSftpValue {
6893        fn from(value: bool) -> Self {
6894            Self::Variant3(value)
6895        }
6896    }
6897
6898    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetSftpValue {
6899        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6900            Self::Variant4(value)
6901        }
6902    }
6903
6904    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6905        for OptionsSetSftpValue
6906    {
6907        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6908            Self::Variant5(value)
6909        }
6910    }
6911
6912    ///`OptionsSetVfsValue`
6913    ///
6914    /// <details><summary>JSON schema</summary>
6915    ///
6916    /// ```json
6917    ///{
6918    ///  "oneOf": [
6919    ///    {
6920    ///      "type": "string"
6921    ///    },
6922    ///    {
6923    ///      "type": "number"
6924    ///    },
6925    ///    {
6926    ///      "type": "integer"
6927    ///    },
6928    ///    {
6929    ///      "type": "boolean"
6930    ///    },
6931    ///    {
6932    ///      "type": "array",
6933    ///      "items": {}
6934    ///    },
6935    ///    {
6936    ///      "type": "object",
6937    ///      "additionalProperties": {}
6938    ///    }
6939    ///  ]
6940    ///}
6941    /// ```
6942    /// </details>
6943    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6944    #[serde(untagged)]
6945    pub enum OptionsSetVfsValue {
6946        Variant0(::std::string::String),
6947        Variant1(f64),
6948        Variant2(i64),
6949        Variant3(bool),
6950        Variant4(::std::vec::Vec<::serde_json::Value>),
6951        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6952    }
6953
6954    impl ::std::convert::From<&Self> for OptionsSetVfsValue {
6955        fn from(value: &OptionsSetVfsValue) -> Self {
6956            value.clone()
6957        }
6958    }
6959
6960    impl ::std::convert::From<f64> for OptionsSetVfsValue {
6961        fn from(value: f64) -> Self {
6962            Self::Variant1(value)
6963        }
6964    }
6965
6966    impl ::std::convert::From<i64> for OptionsSetVfsValue {
6967        fn from(value: i64) -> Self {
6968            Self::Variant2(value)
6969        }
6970    }
6971
6972    impl ::std::convert::From<bool> for OptionsSetVfsValue {
6973        fn from(value: bool) -> Self {
6974            Self::Variant3(value)
6975        }
6976    }
6977
6978    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetVfsValue {
6979        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6980            Self::Variant4(value)
6981        }
6982    }
6983
6984    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6985        for OptionsSetVfsValue
6986    {
6987        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6988            Self::Variant5(value)
6989        }
6990    }
6991
6992    ///`OptionsSetWebdavValue`
6993    ///
6994    /// <details><summary>JSON schema</summary>
6995    ///
6996    /// ```json
6997    ///{
6998    ///  "oneOf": [
6999    ///    {
7000    ///      "type": "string"
7001    ///    },
7002    ///    {
7003    ///      "type": "number"
7004    ///    },
7005    ///    {
7006    ///      "type": "integer"
7007    ///    },
7008    ///    {
7009    ///      "type": "boolean"
7010    ///    },
7011    ///    {
7012    ///      "type": "array",
7013    ///      "items": {}
7014    ///    },
7015    ///    {
7016    ///      "type": "object",
7017    ///      "additionalProperties": {}
7018    ///    }
7019    ///  ]
7020    ///}
7021    /// ```
7022    /// </details>
7023    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7024    #[serde(untagged)]
7025    pub enum OptionsSetWebdavValue {
7026        Variant0(::std::string::String),
7027        Variant1(f64),
7028        Variant2(i64),
7029        Variant3(bool),
7030        Variant4(::std::vec::Vec<::serde_json::Value>),
7031        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
7032    }
7033
7034    impl ::std::convert::From<&Self> for OptionsSetWebdavValue {
7035        fn from(value: &OptionsSetWebdavValue) -> Self {
7036            value.clone()
7037        }
7038    }
7039
7040    impl ::std::convert::From<f64> for OptionsSetWebdavValue {
7041        fn from(value: f64) -> Self {
7042            Self::Variant1(value)
7043        }
7044    }
7045
7046    impl ::std::convert::From<i64> for OptionsSetWebdavValue {
7047        fn from(value: i64) -> Self {
7048            Self::Variant2(value)
7049        }
7050    }
7051
7052    impl ::std::convert::From<bool> for OptionsSetWebdavValue {
7053        fn from(value: bool) -> Self {
7054            Self::Variant3(value)
7055        }
7056    }
7057
7058    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetWebdavValue {
7059        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
7060            Self::Variant4(value)
7061        }
7062    }
7063
7064    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
7065        for OptionsSetWebdavValue
7066    {
7067        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
7068            Self::Variant5(value)
7069        }
7070    }
7071
7072    ///`PluginsctlGetPluginsForTypeResponse`
7073    ///
7074    /// <details><summary>JSON schema</summary>
7075    ///
7076    /// ```json
7077    ///{
7078    ///  "type": "object",
7079    ///  "required": [
7080    ///    "loadedPlugins",
7081    ///    "loadedTestPlugins"
7082    ///  ],
7083    ///  "properties": {
7084    ///    "loadedPlugins": {
7085    ///      "description": "Installed plugins keyed by repository name.",
7086    ///      "type": "object",
7087    ///      "additionalProperties": {
7088    ///        "type": "object",
7089    ///        "additionalProperties": true
7090    ///      }
7091    ///    },
7092    ///    "loadedTestPlugins": {
7093    ///      "description": "Installed test plugins keyed by repository name.",
7094    ///      "type": "object",
7095    ///      "additionalProperties": {
7096    ///        "type": "object",
7097    ///        "additionalProperties": true
7098    ///      }
7099    ///    }
7100    ///  }
7101    ///}
7102    /// ```
7103    /// </details>
7104    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7105    pub struct PluginsctlGetPluginsForTypeResponse {
7106        ///Installed plugins keyed by repository name.
7107        #[serde(rename = "loadedPlugins")]
7108        pub loaded_plugins: ::std::collections::HashMap<
7109            ::std::string::String,
7110            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7111        >,
7112        ///Installed test plugins keyed by repository name.
7113        #[serde(rename = "loadedTestPlugins")]
7114        pub loaded_test_plugins: ::std::collections::HashMap<
7115            ::std::string::String,
7116            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7117        >,
7118    }
7119
7120    impl ::std::convert::From<&PluginsctlGetPluginsForTypeResponse>
7121        for PluginsctlGetPluginsForTypeResponse
7122    {
7123        fn from(value: &PluginsctlGetPluginsForTypeResponse) -> Self {
7124            value.clone()
7125        }
7126    }
7127
7128    ///`PluginsctlListPluginsResponse`
7129    ///
7130    /// <details><summary>JSON schema</summary>
7131    ///
7132    /// ```json
7133    ///{
7134    ///  "type": "object",
7135    ///  "required": [
7136    ///    "loadedPlugins",
7137    ///    "testPlugins"
7138    ///  ],
7139    ///  "properties": {
7140    ///    "loadedPlugins": {
7141    ///      "description": "Metadata entries for installed plugins.",
7142    ///      "type": "array",
7143    ///      "items": {
7144    ///        "type": "object",
7145    ///        "additionalProperties": true
7146    ///      }
7147    ///    },
7148    ///    "testPlugins": {
7149    ///      "description": "Metadata entries for installed test plugins.",
7150    ///      "type": "array",
7151    ///      "items": {
7152    ///        "type": "object",
7153    ///        "additionalProperties": true
7154    ///      }
7155    ///    }
7156    ///  }
7157    ///}
7158    /// ```
7159    /// </details>
7160    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7161    pub struct PluginsctlListPluginsResponse {
7162        ///Metadata entries for installed plugins.
7163        #[serde(rename = "loadedPlugins")]
7164        pub loaded_plugins:
7165            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7166        ///Metadata entries for installed test plugins.
7167        #[serde(rename = "testPlugins")]
7168        pub test_plugins:
7169            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7170    }
7171
7172    impl ::std::convert::From<&PluginsctlListPluginsResponse> for PluginsctlListPluginsResponse {
7173        fn from(value: &PluginsctlListPluginsResponse) -> Self {
7174            value.clone()
7175        }
7176    }
7177
7178    ///`PluginsctlListTestPluginsResponse`
7179    ///
7180    /// <details><summary>JSON schema</summary>
7181    ///
7182    /// ```json
7183    ///{
7184    ///  "type": "object",
7185    ///  "required": [
7186    ///    "loadedTestPlugins"
7187    ///  ],
7188    ///  "properties": {
7189    ///    "loadedTestPlugins": {
7190    ///      "description": "Installed test plugin metadata keyed by
7191    /// repository.",
7192    ///      "type": "object",
7193    ///      "additionalProperties": {
7194    ///        "type": "object",
7195    ///        "additionalProperties": true
7196    ///      }
7197    ///    }
7198    ///  }
7199    ///}
7200    /// ```
7201    /// </details>
7202    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7203    pub struct PluginsctlListTestPluginsResponse {
7204        ///Installed test plugin metadata keyed by repository.
7205        #[serde(rename = "loadedTestPlugins")]
7206        pub loaded_test_plugins: ::std::collections::HashMap<
7207            ::std::string::String,
7208            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7209        >,
7210    }
7211
7212    impl ::std::convert::From<&PluginsctlListTestPluginsResponse>
7213        for PluginsctlListTestPluginsResponse
7214    {
7215        fn from(value: &PluginsctlListTestPluginsResponse) -> Self {
7216            value.clone()
7217        }
7218    }
7219
7220    ///`RcError`
7221    ///
7222    /// <details><summary>JSON schema</summary>
7223    ///
7224    /// ```json
7225    ///{
7226    ///  "type": "object",
7227    ///  "required": [
7228    ///    "error",
7229    ///    "input",
7230    ///    "path",
7231    ///    "status"
7232    ///  ],
7233    ///  "properties": {
7234    ///    "error": {
7235    ///      "type": "string"
7236    ///    },
7237    ///    "input": {
7238    ///      "description": "Original request parameters echoed for debugging.",
7239    ///      "type": [
7240    ///        "object",
7241    ///        "null"
7242    ///      ],
7243    ///      "additionalProperties": {}
7244    ///    },
7245    ///    "path": {
7246    ///      "type": "string"
7247    ///    },
7248    ///    "status": {
7249    ///      "type": "integer"
7250    ///    }
7251    ///  }
7252    ///}
7253    /// ```
7254    /// </details>
7255    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7256    pub struct RcError {
7257        pub error: ::std::string::String,
7258        ///Original request parameters echoed for debugging.
7259        pub input:
7260            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7261        pub path: ::std::string::String,
7262        pub status: i64,
7263    }
7264
7265    impl ::std::convert::From<&RcError> for RcError {
7266        fn from(value: &RcError) -> Self {
7267            value.clone()
7268        }
7269    }
7270
7271    ///`RcListResponse`
7272    ///
7273    /// <details><summary>JSON schema</summary>
7274    ///
7275    /// ```json
7276    ///{
7277    ///  "type": "object",
7278    ///  "required": [
7279    ///    "commands"
7280    ///  ],
7281    ///  "properties": {
7282    ///    "commands": {
7283    ///      "type": "array",
7284    ///      "items": {
7285    ///        "type": "object",
7286    ///        "properties": {
7287    ///          "AuthRequired": {
7288    ///            "type": "boolean"
7289    ///          },
7290    ///          "Help": {
7291    ///            "type": "string"
7292    ///          },
7293    ///          "NeedsRequest": {
7294    ///            "type": "boolean"
7295    ///          },
7296    ///          "NeedsResponse": {
7297    ///            "type": "boolean"
7298    ///          },
7299    ///          "Path": {
7300    ///            "type": "string"
7301    ///          },
7302    ///          "Title": {
7303    ///            "type": "string"
7304    ///          }
7305    ///        },
7306    ///        "additionalProperties": true
7307    ///      }
7308    ///    }
7309    ///  }
7310    ///}
7311    /// ```
7312    /// </details>
7313    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7314    pub struct RcListResponse {
7315        pub commands: ::std::vec::Vec<RcListResponseCommandsItem>,
7316    }
7317
7318    impl ::std::convert::From<&RcListResponse> for RcListResponse {
7319        fn from(value: &RcListResponse) -> Self {
7320            value.clone()
7321        }
7322    }
7323
7324    ///`RcListResponseCommandsItem`
7325    ///
7326    /// <details><summary>JSON schema</summary>
7327    ///
7328    /// ```json
7329    ///{
7330    ///  "type": "object",
7331    ///  "properties": {
7332    ///    "AuthRequired": {
7333    ///      "type": "boolean"
7334    ///    },
7335    ///    "Help": {
7336    ///      "type": "string"
7337    ///    },
7338    ///    "NeedsRequest": {
7339    ///      "type": "boolean"
7340    ///    },
7341    ///    "NeedsResponse": {
7342    ///      "type": "boolean"
7343    ///    },
7344    ///    "Path": {
7345    ///      "type": "string"
7346    ///    },
7347    ///    "Title": {
7348    ///      "type": "string"
7349    ///    }
7350    ///  },
7351    ///  "additionalProperties": true
7352    ///}
7353    /// ```
7354    /// </details>
7355    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7356    pub struct RcListResponseCommandsItem {
7357        #[serde(
7358            rename = "AuthRequired",
7359            default,
7360            skip_serializing_if = "::std::option::Option::is_none"
7361        )]
7362        pub auth_required: ::std::option::Option<bool>,
7363        #[serde(
7364            rename = "Help",
7365            default,
7366            skip_serializing_if = "::std::option::Option::is_none"
7367        )]
7368        pub help: ::std::option::Option<::std::string::String>,
7369        #[serde(
7370            rename = "NeedsRequest",
7371            default,
7372            skip_serializing_if = "::std::option::Option::is_none"
7373        )]
7374        pub needs_request: ::std::option::Option<bool>,
7375        #[serde(
7376            rename = "NeedsResponse",
7377            default,
7378            skip_serializing_if = "::std::option::Option::is_none"
7379        )]
7380        pub needs_response: ::std::option::Option<bool>,
7381        #[serde(
7382            rename = "Path",
7383            default,
7384            skip_serializing_if = "::std::option::Option::is_none"
7385        )]
7386        pub path: ::std::option::Option<::std::string::String>,
7387        #[serde(
7388            rename = "Title",
7389            default,
7390            skip_serializing_if = "::std::option::Option::is_none"
7391        )]
7392        pub title: ::std::option::Option<::std::string::String>,
7393    }
7394
7395    impl ::std::convert::From<&RcListResponseCommandsItem> for RcListResponseCommandsItem {
7396        fn from(value: &RcListResponseCommandsItem) -> Self {
7397            value.clone()
7398        }
7399    }
7400
7401    impl ::std::default::Default for RcListResponseCommandsItem {
7402        fn default() -> Self {
7403            Self {
7404                auth_required: Default::default(),
7405                help: Default::default(),
7406                needs_request: Default::default(),
7407                needs_response: Default::default(),
7408                path: Default::default(),
7409                title: Default::default(),
7410            }
7411        }
7412    }
7413
7414    ///`ServeListResponse`
7415    ///
7416    /// <details><summary>JSON schema</summary>
7417    ///
7418    /// ```json
7419    ///{
7420    ///  "type": "object",
7421    ///  "required": [
7422    ///    "list"
7423    ///  ],
7424    ///  "properties": {
7425    ///    "list": {
7426    ///      "type": "array",
7427    ///      "items": {
7428    ///        "type": "object",
7429    ///        "required": [
7430    ///          "addr",
7431    ///          "id"
7432    ///        ],
7433    ///        "properties": {
7434    ///          "addr": {
7435    ///            "description": "Address and port the server is listening
7436    /// on.",
7437    ///            "type": "string"
7438    ///          },
7439    ///          "id": {
7440    ///            "description": "Identifier returned by `serve/start`.",
7441    ///            "type": "string"
7442    ///          },
7443    ///          "params": {
7444    ///            "description": "Serve configuration parameters supplied at
7445    /// startup.",
7446    ///            "type": "object",
7447    ///            "required": [
7448    ///              "fs",
7449    ///              "id",
7450    ///              "type"
7451    ///            ],
7452    ///            "properties": {
7453    ///              "fs": {
7454    ///                "type": "string"
7455    ///              },
7456    ///              "opt": {
7457    ///                "type": "object",
7458    ///                "additionalProperties": true
7459    ///              },
7460    ///              "type": {
7461    ///                "type": "string"
7462    ///              },
7463    ///              "vfsOpt": {
7464    ///                "type": "object",
7465    ///                "additionalProperties": true
7466    ///              }
7467    ///            },
7468    ///            "additionalProperties": true
7469    ///          }
7470    ///        },
7471    ///        "additionalProperties": false
7472    ///      }
7473    ///    }
7474    ///  }
7475    ///}
7476    /// ```
7477    /// </details>
7478    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7479    pub struct ServeListResponse {
7480        pub list: ::std::vec::Vec<ServeListResponseListItem>,
7481    }
7482
7483    impl ::std::convert::From<&ServeListResponse> for ServeListResponse {
7484        fn from(value: &ServeListResponse) -> Self {
7485            value.clone()
7486        }
7487    }
7488
7489    ///`ServeListResponseListItem`
7490    ///
7491    /// <details><summary>JSON schema</summary>
7492    ///
7493    /// ```json
7494    ///{
7495    ///  "type": "object",
7496    ///  "required": [
7497    ///    "addr",
7498    ///    "id"
7499    ///  ],
7500    ///  "properties": {
7501    ///    "addr": {
7502    ///      "description": "Address and port the server is listening on.",
7503    ///      "type": "string"
7504    ///    },
7505    ///    "id": {
7506    ///      "description": "Identifier returned by `serve/start`.",
7507    ///      "type": "string"
7508    ///    },
7509    ///    "params": {
7510    ///      "description": "Serve configuration parameters supplied at
7511    /// startup.",
7512    ///      "type": "object",
7513    ///      "required": [
7514    ///        "fs",
7515    ///        "id",
7516    ///        "type"
7517    ///      ],
7518    ///      "properties": {
7519    ///        "fs": {
7520    ///          "type": "string"
7521    ///        },
7522    ///        "opt": {
7523    ///          "type": "object",
7524    ///          "additionalProperties": true
7525    ///        },
7526    ///        "type": {
7527    ///          "type": "string"
7528    ///        },
7529    ///        "vfsOpt": {
7530    ///          "type": "object",
7531    ///          "additionalProperties": true
7532    ///        }
7533    ///      },
7534    ///      "additionalProperties": true
7535    ///    }
7536    ///  },
7537    ///  "additionalProperties": false
7538    ///}
7539    /// ```
7540    /// </details>
7541    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7542    #[serde(deny_unknown_fields)]
7543    pub struct ServeListResponseListItem {
7544        ///Address and port the server is listening on.
7545        pub addr: ::std::string::String,
7546        ///Identifier returned by `serve/start`.
7547        pub id: ::std::string::String,
7548        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7549        pub params: ::std::option::Option<ServeListResponseListItemParams>,
7550    }
7551
7552    impl ::std::convert::From<&ServeListResponseListItem> for ServeListResponseListItem {
7553        fn from(value: &ServeListResponseListItem) -> Self {
7554            value.clone()
7555        }
7556    }
7557
7558    ///Serve configuration parameters supplied at startup.
7559    ///
7560    /// <details><summary>JSON schema</summary>
7561    ///
7562    /// ```json
7563    ///{
7564    ///  "description": "Serve configuration parameters supplied at startup.",
7565    ///  "type": "object",
7566    ///  "required": [
7567    ///    "fs",
7568    ///    "id",
7569    ///    "type"
7570    ///  ],
7571    ///  "properties": {
7572    ///    "fs": {
7573    ///      "type": "string"
7574    ///    },
7575    ///    "opt": {
7576    ///      "type": "object",
7577    ///      "additionalProperties": true
7578    ///    },
7579    ///    "type": {
7580    ///      "type": "string"
7581    ///    },
7582    ///    "vfsOpt": {
7583    ///      "type": "object",
7584    ///      "additionalProperties": true
7585    ///    }
7586    ///  },
7587    ///  "additionalProperties": true
7588    ///}
7589    /// ```
7590    /// </details>
7591    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7592    pub struct ServeListResponseListItemParams {
7593        pub fs: ::std::string::String,
7594        pub id: ::serde_json::Value,
7595        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
7596        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7597        #[serde(rename = "type")]
7598        pub type_: ::std::string::String,
7599        #[serde(
7600            rename = "vfsOpt",
7601            default,
7602            skip_serializing_if = "::serde_json::Map::is_empty"
7603        )]
7604        pub vfs_opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7605    }
7606
7607    impl ::std::convert::From<&ServeListResponseListItemParams> for ServeListResponseListItemParams {
7608        fn from(value: &ServeListResponseListItemParams) -> Self {
7609            value.clone()
7610        }
7611    }
7612
7613    ///`ServeStartResponse`
7614    ///
7615    /// <details><summary>JSON schema</summary>
7616    ///
7617    /// ```json
7618    ///{
7619    ///  "type": "object",
7620    ///  "required": [
7621    ///    "addr",
7622    ///    "id"
7623    ///  ],
7624    ///  "properties": {
7625    ///    "addr": {
7626    ///      "description": "Address and port the server is listening on.",
7627    ///      "type": "string"
7628    ///    },
7629    ///    "id": {
7630    ///      "description": "Identifier to pass to `serve/stop`.",
7631    ///      "type": "string"
7632    ///    }
7633    ///  }
7634    ///}
7635    /// ```
7636    /// </details>
7637    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7638    pub struct ServeStartResponse {
7639        ///Address and port the server is listening on.
7640        pub addr: ::std::string::String,
7641        ///Identifier to pass to `serve/stop`.
7642        pub id: ::std::string::String,
7643    }
7644
7645    impl ::std::convert::From<&ServeStartResponse> for ServeStartResponse {
7646        fn from(value: &ServeStartResponse) -> Self {
7647            value.clone()
7648        }
7649    }
7650
7651    ///`SyncBisyncResponse`
7652    ///
7653    /// <details><summary>JSON schema</summary>
7654    ///
7655    /// ```json
7656    ///{
7657    ///  "type": "object",
7658    ///  "properties": {
7659    ///    "jobid": {
7660    ///      "description": "Job ID of the operation.",
7661    ///      "type": "integer"
7662    ///    }
7663    ///  }
7664    ///}
7665    /// ```
7666    /// </details>
7667    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7668    pub struct SyncBisyncResponse {
7669        ///Job ID of the operation.
7670        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7671        pub jobid: ::std::option::Option<i64>,
7672    }
7673
7674    impl ::std::convert::From<&SyncBisyncResponse> for SyncBisyncResponse {
7675        fn from(value: &SyncBisyncResponse) -> Self {
7676            value.clone()
7677        }
7678    }
7679
7680    impl ::std::default::Default for SyncBisyncResponse {
7681        fn default() -> Self {
7682            Self {
7683                jobid: Default::default(),
7684            }
7685        }
7686    }
7687
7688    ///`SyncCopyResponse`
7689    ///
7690    /// <details><summary>JSON schema</summary>
7691    ///
7692    /// ```json
7693    ///{
7694    ///  "type": "object",
7695    ///  "properties": {
7696    ///    "jobid": {
7697    ///      "description": "Job ID of the operation.",
7698    ///      "type": "integer"
7699    ///    }
7700    ///  }
7701    ///}
7702    /// ```
7703    /// </details>
7704    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7705    pub struct SyncCopyResponse {
7706        ///Job ID of the operation.
7707        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7708        pub jobid: ::std::option::Option<i64>,
7709    }
7710
7711    impl ::std::convert::From<&SyncCopyResponse> for SyncCopyResponse {
7712        fn from(value: &SyncCopyResponse) -> Self {
7713            value.clone()
7714        }
7715    }
7716
7717    impl ::std::default::Default for SyncCopyResponse {
7718        fn default() -> Self {
7719            Self {
7720                jobid: Default::default(),
7721            }
7722        }
7723    }
7724
7725    ///`SyncMoveResponse`
7726    ///
7727    /// <details><summary>JSON schema</summary>
7728    ///
7729    /// ```json
7730    ///{
7731    ///  "type": "object",
7732    ///  "properties": {
7733    ///    "jobid": {
7734    ///      "description": "Job ID of the operation.",
7735    ///      "type": "integer"
7736    ///    }
7737    ///  }
7738    ///}
7739    /// ```
7740    /// </details>
7741    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7742    pub struct SyncMoveResponse {
7743        ///Job ID of the operation.
7744        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7745        pub jobid: ::std::option::Option<i64>,
7746    }
7747
7748    impl ::std::convert::From<&SyncMoveResponse> for SyncMoveResponse {
7749        fn from(value: &SyncMoveResponse) -> Self {
7750            value.clone()
7751        }
7752    }
7753
7754    impl ::std::default::Default for SyncMoveResponse {
7755        fn default() -> Self {
7756            Self {
7757                jobid: Default::default(),
7758            }
7759        }
7760    }
7761
7762    ///`SyncSyncResponse`
7763    ///
7764    /// <details><summary>JSON schema</summary>
7765    ///
7766    /// ```json
7767    ///{
7768    ///  "type": "object",
7769    ///  "properties": {
7770    ///    "jobid": {
7771    ///      "description": "Job ID of the operation.",
7772    ///      "type": "integer"
7773    ///    }
7774    ///  }
7775    ///}
7776    /// ```
7777    /// </details>
7778    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7779    pub struct SyncSyncResponse {
7780        ///Job ID of the operation.
7781        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7782        pub jobid: ::std::option::Option<i64>,
7783    }
7784
7785    impl ::std::convert::From<&SyncSyncResponse> for SyncSyncResponse {
7786        fn from(value: &SyncSyncResponse) -> Self {
7787            value.clone()
7788        }
7789    }
7790
7791    impl ::std::default::Default for SyncSyncResponse {
7792        fn default() -> Self {
7793            Self {
7794                jobid: Default::default(),
7795            }
7796        }
7797    }
7798
7799    ///`VfsForgetResponse`
7800    ///
7801    /// <details><summary>JSON schema</summary>
7802    ///
7803    /// ```json
7804    ///{
7805    ///  "type": "object",
7806    ///  "required": [
7807    ///    "forgotten"
7808    ///  ],
7809    ///  "properties": {
7810    ///    "forgotten": {
7811    ///      "description": "Paths that were successfully forgotten.",
7812    ///      "type": "array",
7813    ///      "items": {
7814    ///        "type": "string"
7815    ///      }
7816    ///    }
7817    ///  }
7818    ///}
7819    /// ```
7820    /// </details>
7821    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7822    pub struct VfsForgetResponse {
7823        ///Paths that were successfully forgotten.
7824        pub forgotten: ::std::vec::Vec<::std::string::String>,
7825    }
7826
7827    impl ::std::convert::From<&VfsForgetResponse> for VfsForgetResponse {
7828        fn from(value: &VfsForgetResponse) -> Self {
7829            value.clone()
7830        }
7831    }
7832
7833    ///`VfsListResponse`
7834    ///
7835    /// <details><summary>JSON schema</summary>
7836    ///
7837    /// ```json
7838    ///{
7839    ///  "type": "object",
7840    ///  "required": [
7841    ///    "vfses"
7842    ///  ],
7843    ///  "properties": {
7844    ///    "vfses": {
7845    ///      "description": "VFS name that can be used with other VFS
7846    /// endpoints.",
7847    ///      "type": "array",
7848    ///      "items": {
7849    ///        "type": "string"
7850    ///      }
7851    ///    }
7852    ///  }
7853    ///}
7854    /// ```
7855    /// </details>
7856    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7857    pub struct VfsListResponse {
7858        ///VFS name that can be used with other VFS endpoints.
7859        pub vfses: ::std::vec::Vec<::std::string::String>,
7860    }
7861
7862    impl ::std::convert::From<&VfsListResponse> for VfsListResponse {
7863        fn from(value: &VfsListResponse) -> Self {
7864            value.clone()
7865        }
7866    }
7867
7868    ///`VfsQueueResponse`
7869    ///
7870    /// <details><summary>JSON schema</summary>
7871    ///
7872    /// ```json
7873    ///{
7874    ///  "type": "object",
7875    ///  "properties": {
7876    ///    "queued": {
7877    ///      "type": "array",
7878    ///      "items": {
7879    ///        "description": "Queued item metadata such as name, size, expiry,
7880    /// and upload state.",
7881    ///        "type": "object",
7882    ///        "additionalProperties": true
7883    ///      }
7884    ///    }
7885    ///  }
7886    ///}
7887    /// ```
7888    /// </details>
7889    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7890    pub struct VfsQueueResponse {
7891        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7892        pub queued: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7893    }
7894
7895    impl ::std::convert::From<&VfsQueueResponse> for VfsQueueResponse {
7896        fn from(value: &VfsQueueResponse) -> Self {
7897            value.clone()
7898        }
7899    }
7900
7901    impl ::std::default::Default for VfsQueueResponse {
7902        fn default() -> Self {
7903            Self {
7904                queued: Default::default(),
7905            }
7906        }
7907    }
7908
7909    ///`VfsRefreshResponse`
7910    ///
7911    /// <details><summary>JSON schema</summary>
7912    ///
7913    /// ```json
7914    ///{
7915    ///  "type": "object",
7916    ///  "required": [
7917    ///    "result"
7918    ///  ],
7919    ///  "properties": {
7920    ///    "result": {
7921    ///      "description": "Map of refreshed directories to status messages.",
7922    ///      "type": "object",
7923    ///      "additionalProperties": {
7924    ///        "type": "string"
7925    ///      }
7926    ///    }
7927    ///  }
7928    ///}
7929    /// ```
7930    /// </details>
7931    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7932    pub struct VfsRefreshResponse {
7933        ///Map of refreshed directories to status messages.
7934        pub result: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
7935    }
7936
7937    impl ::std::convert::From<&VfsRefreshResponse> for VfsRefreshResponse {
7938        fn from(value: &VfsRefreshResponse) -> Self {
7939            value.clone()
7940        }
7941    }
7942
7943    ///`VfsStatsResponse`
7944    ///
7945    /// <details><summary>JSON schema</summary>
7946    ///
7947    /// ```json
7948    ///{
7949    ///  "type": "object",
7950    ///  "required": [
7951    ///    "fs",
7952    ///    "inUse",
7953    ///    "metadataCache",
7954    ///    "opt"
7955    ///  ],
7956    ///  "properties": {
7957    ///    "diskCache": {
7958    ///      "description": "Disk cache metrics when caching is enabled.",
7959    ///      "type": [
7960    ///        "object",
7961    ///        "null"
7962    ///      ],
7963    ///      "additionalProperties": true
7964    ///    },
7965    ///    "fs": {
7966    ///      "description": "Name of the VFS.",
7967    ///      "type": "string"
7968    ///    },
7969    ///    "inUse": {
7970    ///      "description": "Number of active references to the VFS.",
7971    ///      "type": "integer"
7972    ///    },
7973    ///    "metadataCache": {
7974    ///      "description": "In-memory metadata cache counters.",
7975    ///      "type": "object",
7976    ///      "additionalProperties": {
7977    ///        "type": "integer"
7978    ///      }
7979    ///    },
7980    ///    "opt": {
7981    ///      "description": "Effective options applied to the VFS.",
7982    ///      "type": "object",
7983    ///      "additionalProperties": true
7984    ///    }
7985    ///  }
7986    ///}
7987    /// ```
7988    /// </details>
7989    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7990    pub struct VfsStatsResponse {
7991        ///Disk cache metrics when caching is enabled.
7992        #[serde(
7993            rename = "diskCache",
7994            default,
7995            skip_serializing_if = "::std::option::Option::is_none"
7996        )]
7997        pub disk_cache:
7998            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7999        ///Name of the VFS.
8000        pub fs: ::std::string::String,
8001        ///Number of active references to the VFS.
8002        #[serde(rename = "inUse")]
8003        pub in_use: i64,
8004        ///In-memory metadata cache counters.
8005        #[serde(rename = "metadataCache")]
8006        pub metadata_cache: ::std::collections::HashMap<::std::string::String, i64>,
8007        ///Effective options applied to the VFS.
8008        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
8009    }
8010
8011    impl ::std::convert::From<&VfsStatsResponse> for VfsStatsResponse {
8012        fn from(value: &VfsStatsResponse) -> Self {
8013            value.clone()
8014        }
8015    }
8016}
8017
8018#[derive(Clone, Debug)]
8019///Client for Rclone RC API
8020///
8021///Full OpenAPI specification for the Rclone RC API.
8022///
8023///Version: 1.73.0
8024pub struct Client {
8025    pub(crate) baseurl: String,
8026    pub(crate) client: reqwest::Client,
8027}
8028
8029impl Client {
8030    /// Create a new client.
8031    ///
8032    /// `baseurl` is the base URL provided to the internal
8033    /// `reqwest::Client`, and should include a scheme and hostname,
8034    /// as well as port and a path stem if applicable.
8035    pub fn new(baseurl: &str) -> Self {
8036        #[cfg(not(target_arch = "wasm32"))]
8037        let client = {
8038            let dur = ::std::time::Duration::from_secs(15u64);
8039            reqwest::ClientBuilder::new()
8040                .connect_timeout(dur)
8041                .timeout(dur)
8042        };
8043        #[cfg(target_arch = "wasm32")]
8044        let client = reqwest::ClientBuilder::new();
8045        Self::new_with_client(baseurl, client.build().unwrap())
8046    }
8047
8048    /// Construct a new client with an existing `reqwest::Client`,
8049    /// allowing more control over its configuration.
8050    ///
8051    /// `baseurl` is the base URL provided to the internal
8052    /// `reqwest::Client`, and should include a scheme and hostname,
8053    /// as well as port and a path stem if applicable.
8054    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
8055        Self {
8056            baseurl: baseurl.to_string(),
8057            client,
8058        }
8059    }
8060}
8061
8062impl ClientInfo<()> for Client {
8063    fn api_version() -> &'static str {
8064        "1.73.0"
8065    }
8066
8067    fn baseurl(&self) -> &str {
8068        self.baseurl.as_str()
8069    }
8070
8071    fn client(&self) -> &reqwest::Client {
8072        &self.client
8073    }
8074
8075    fn inner(&self) -> &() {
8076        &()
8077    }
8078}
8079
8080impl ClientHooks<()> for &Client {}
8081#[allow(clippy::all)]
8082impl Client {
8083    ///Echo request parameters
8084    ///
8085    ///Returns all supplied parameters unchanged so you can verify RC
8086    /// connectivity.
8087    ///
8088    ///Sends a `POST` request to `/rc/noop`
8089    ///
8090    ///Arguments:
8091    /// - `async_`: Run the command asynchronously. Returns a job id
8092    ///   immediately.
8093    /// - `params`: Additional arbitrary parameters allowed.
8094    pub async fn rc_noop<'a>(
8095        &'a self,
8096        async_: Option<bool>,
8097        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8098    ) -> Result<
8099        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8100        Error<types::RcError>,
8101    > {
8102        let url = format!("{}/rc/noop", self.baseurl,);
8103        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8104        header_map.append(
8105            ::reqwest::header::HeaderName::from_static("api-version"),
8106            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8107        );
8108        #[allow(unused_mut)]
8109        let mut request = self
8110            .client
8111            .post(url)
8112            .header(
8113                ::reqwest::header::ACCEPT,
8114                ::reqwest::header::HeaderValue::from_static("application/json"),
8115            )
8116            .query(&progenitor_client::QueryParam::new("_async", &async_))
8117            .query(&progenitor_client::QueryParam::new("params", &params))
8118            .headers(header_map)
8119            .build()?;
8120        let info = OperationInfo {
8121            operation_id: "rc_noop",
8122        };
8123        self.pre(&mut request, &info).await?;
8124        let result = self.exec(request, &info).await;
8125        self.post(&result, &info).await?;
8126        let response = result?;
8127        match response.status().as_u16() {
8128            200u16 => ResponseValue::from_response(response).await,
8129            400u16..=499u16 => Err(Error::ErrorResponse(
8130                ResponseValue::from_response(response).await?,
8131            )),
8132            500u16..=599u16 => Err(Error::ErrorResponse(
8133                ResponseValue::from_response(response).await?,
8134            )),
8135            _ => Err(Error::UnexpectedResponse(response)),
8136        }
8137    }
8138
8139    ///Remove trashed files
8140    ///
8141    ///Permanently removes trashed objects from the specified remote path.
8142    ///
8143    ///Sends a `POST` request to `/operations/cleanup`
8144    ///
8145    ///Arguments:
8146    /// - `async_`: Run the command asynchronously. Returns a job id
8147    ///   immediately.
8148    /// - `group`: Assign the request to a custom stats group.
8149    /// - `fs`: Remote name or path to clean up, for example `drive:`.
8150    pub async fn operations_cleanup<'a>(
8151        &'a self,
8152        async_: Option<bool>,
8153        group: Option<&'a str>,
8154        fs: &'a str,
8155    ) -> Result<
8156        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8157        Error<types::RcError>,
8158    > {
8159        let url = format!("{}/operations/cleanup", self.baseurl,);
8160        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8161        header_map.append(
8162            ::reqwest::header::HeaderName::from_static("api-version"),
8163            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8164        );
8165        #[allow(unused_mut)]
8166        let mut request = self
8167            .client
8168            .post(url)
8169            .header(
8170                ::reqwest::header::ACCEPT,
8171                ::reqwest::header::HeaderValue::from_static("application/json"),
8172            )
8173            .query(&progenitor_client::QueryParam::new("_async", &async_))
8174            .query(&progenitor_client::QueryParam::new("_group", &group))
8175            .query(&progenitor_client::QueryParam::new("fs", &fs))
8176            .headers(header_map)
8177            .build()?;
8178        let info = OperationInfo {
8179            operation_id: "operations_cleanup",
8180        };
8181        self.pre(&mut request, &info).await?;
8182        let result = self.exec(request, &info).await;
8183        self.post(&result, &info).await?;
8184        let response = result?;
8185        match response.status().as_u16() {
8186            200u16 => ResponseValue::from_response(response).await,
8187            400u16..=499u16 => Err(Error::ErrorResponse(
8188                ResponseValue::from_response(response).await?,
8189            )),
8190            500u16..=599u16 => Err(Error::ErrorResponse(
8191                ResponseValue::from_response(response).await?,
8192            )),
8193            _ => Err(Error::UnexpectedResponse(response)),
8194        }
8195    }
8196
8197    ///Copy a single file
8198    ///
8199    ///Copies one object from a source remote and path to a destination remote
8200    /// and path.
8201    ///
8202    ///Sends a `POST` request to `/operations/copyfile`
8203    ///
8204    ///Arguments:
8205    /// - `async_`: Run the command asynchronously. Returns a job id
8206    ///   immediately.
8207    /// - `group`: Assign the request to a custom stats group.
8208    /// - `dst_fs`: Destination remote name or path, such as `drive2:` or `/`
8209    ///   for local filesystem.
8210    /// - `dst_remote`: Target path within `dstFs` where the file should be
8211    ///   written.
8212    /// - `src_fs`: Source remote name or path, such as `drive:` or `/` for the
8213    ///   local filesystem.
8214    /// - `src_remote`: Path to the source object within `srcFs`, for example
8215    ///   `dir/file.txt`.
8216    pub async fn operations_copyfile<'a>(
8217        &'a self,
8218        async_: Option<bool>,
8219        group: Option<&'a str>,
8220        dst_fs: &'a str,
8221        dst_remote: &'a str,
8222        src_fs: &'a str,
8223        src_remote: &'a str,
8224    ) -> Result<
8225        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8226        Error<types::RcError>,
8227    > {
8228        let url = format!("{}/operations/copyfile", self.baseurl,);
8229        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8230        header_map.append(
8231            ::reqwest::header::HeaderName::from_static("api-version"),
8232            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8233        );
8234        #[allow(unused_mut)]
8235        let mut request = self
8236            .client
8237            .post(url)
8238            .header(
8239                ::reqwest::header::ACCEPT,
8240                ::reqwest::header::HeaderValue::from_static("application/json"),
8241            )
8242            .query(&progenitor_client::QueryParam::new("_async", &async_))
8243            .query(&progenitor_client::QueryParam::new("_group", &group))
8244            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
8245            .query(&progenitor_client::QueryParam::new(
8246                "dstRemote",
8247                &dst_remote,
8248            ))
8249            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
8250            .query(&progenitor_client::QueryParam::new(
8251                "srcRemote",
8252                &src_remote,
8253            ))
8254            .headers(header_map)
8255            .build()?;
8256        let info = OperationInfo {
8257            operation_id: "operations_copyfile",
8258        };
8259        self.pre(&mut request, &info).await?;
8260        let result = self.exec(request, &info).await;
8261        self.post(&result, &info).await?;
8262        let response = result?;
8263        match response.status().as_u16() {
8264            200u16 => ResponseValue::from_response(response).await,
8265            400u16..=499u16 => Err(Error::ErrorResponse(
8266                ResponseValue::from_response(response).await?,
8267            )),
8268            500u16..=599u16 => Err(Error::ErrorResponse(
8269                ResponseValue::from_response(response).await?,
8270            )),
8271            _ => Err(Error::UnexpectedResponse(response)),
8272        }
8273    }
8274
8275    ///Copy from URL
8276    ///
8277    ///Downloads a public URL and stores it at the requested remote path.
8278    ///
8279    ///Sends a `POST` request to `/operations/copyurl`
8280    ///
8281    ///Arguments:
8282    /// - `async_`: Run the command asynchronously. Returns a job id
8283    ///   immediately.
8284    /// - `group`: Assign the request to a custom stats group.
8285    /// - `auto_filename`: Set to true to derive the destination filename from
8286    ///   the URL.
8287    /// - `fs`: Remote name or path that will receive the downloaded file, e.g.
8288    ///   `drive:`.
8289    /// - `remote`: Destination path within `fs` where the fetched object will
8290    ///   be stored.
8291    /// - `url`: Source URL to fetch the object from.
8292    pub async fn operations_copyurl<'a>(
8293        &'a self,
8294        async_: Option<bool>,
8295        group: Option<&'a str>,
8296        auto_filename: Option<bool>,
8297        fs: &'a str,
8298        remote: &'a str,
8299        url: &'a str,
8300    ) -> Result<
8301        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8302        Error<types::RcError>,
8303    > {
8304        let _url = format!("{}/operations/copyurl", self.baseurl,);
8305        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8306        header_map.append(
8307            ::reqwest::header::HeaderName::from_static("api-version"),
8308            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8309        );
8310        #[allow(unused_mut)]
8311        let mut request = self
8312            .client
8313            .post(_url)
8314            .header(
8315                ::reqwest::header::ACCEPT,
8316                ::reqwest::header::HeaderValue::from_static("application/json"),
8317            )
8318            .query(&progenitor_client::QueryParam::new("_async", &async_))
8319            .query(&progenitor_client::QueryParam::new("_group", &group))
8320            .query(&progenitor_client::QueryParam::new(
8321                "autoFilename",
8322                &auto_filename,
8323            ))
8324            .query(&progenitor_client::QueryParam::new("fs", &fs))
8325            .query(&progenitor_client::QueryParam::new("remote", &remote))
8326            .query(&progenitor_client::QueryParam::new("url", &url))
8327            .headers(header_map)
8328            .build()?;
8329        let info = OperationInfo {
8330            operation_id: "operations_copyurl",
8331        };
8332        self.pre(&mut request, &info).await?;
8333        let result = self.exec(request, &info).await;
8334        self.post(&result, &info).await?;
8335        let response = result?;
8336        match response.status().as_u16() {
8337            200u16 => ResponseValue::from_response(response).await,
8338            400u16..=499u16 => Err(Error::ErrorResponse(
8339                ResponseValue::from_response(response).await?,
8340            )),
8341            500u16..=599u16 => Err(Error::ErrorResponse(
8342                ResponseValue::from_response(response).await?,
8343            )),
8344            _ => Err(Error::UnexpectedResponse(response)),
8345        }
8346    }
8347
8348    ///Delete objects in path
8349    ///
8350    ///Deletes matching files and directories for the provided remote,
8351    /// honouring filters and config overrides.
8352    ///
8353    ///Sends a `POST` request to `/operations/delete`
8354    ///
8355    ///Arguments:
8356    /// - `async_`: Run the command asynchronously. Returns a job id
8357    ///   immediately.
8358    /// - `config`: JSON encoded config overrides applied for this call only.
8359    /// - `filter`: JSON encoded filter overrides applied for this call only.
8360    /// - `group`: Assign the request to a custom stats group.
8361    /// - `fs`: Remote name or path whose contents should be removed.
8362    pub async fn operations_delete<'a>(
8363        &'a self,
8364        async_: Option<bool>,
8365        config: Option<&'a str>,
8366        filter: Option<&'a str>,
8367        group: Option<&'a str>,
8368        fs: &'a str,
8369    ) -> Result<
8370        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8371        Error<types::RcError>,
8372    > {
8373        let url = format!("{}/operations/delete", self.baseurl,);
8374        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8375        header_map.append(
8376            ::reqwest::header::HeaderName::from_static("api-version"),
8377            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8378        );
8379        #[allow(unused_mut)]
8380        let mut request = self
8381            .client
8382            .post(url)
8383            .header(
8384                ::reqwest::header::ACCEPT,
8385                ::reqwest::header::HeaderValue::from_static("application/json"),
8386            )
8387            .query(&progenitor_client::QueryParam::new("_async", &async_))
8388            .query(&progenitor_client::QueryParam::new("_config", &config))
8389            .query(&progenitor_client::QueryParam::new("_filter", &filter))
8390            .query(&progenitor_client::QueryParam::new("_group", &group))
8391            .query(&progenitor_client::QueryParam::new("fs", &fs))
8392            .headers(header_map)
8393            .build()?;
8394        let info = OperationInfo {
8395            operation_id: "operations_delete",
8396        };
8397        self.pre(&mut request, &info).await?;
8398        let result = self.exec(request, &info).await;
8399        self.post(&result, &info).await?;
8400        let response = result?;
8401        match response.status().as_u16() {
8402            200u16 => ResponseValue::from_response(response).await,
8403            400u16..=499u16 => Err(Error::ErrorResponse(
8404                ResponseValue::from_response(response).await?,
8405            )),
8406            500u16..=599u16 => Err(Error::ErrorResponse(
8407                ResponseValue::from_response(response).await?,
8408            )),
8409            _ => Err(Error::UnexpectedResponse(response)),
8410        }
8411    }
8412
8413    ///Delete single file
8414    ///
8415    ///Removes a specific object from the remote.
8416    ///
8417    ///Sends a `POST` request to `/operations/deletefile`
8418    ///
8419    ///Arguments:
8420    /// - `async_`: Run the command asynchronously. Returns a job id
8421    ///   immediately.
8422    /// - `group`: Assign the request to a custom stats group.
8423    /// - `fs`: Remote name or path that contains the file to delete.
8424    /// - `remote`: Exact path to the file within `fs` that should be deleted.
8425    pub async fn operations_deletefile<'a>(
8426        &'a self,
8427        async_: Option<bool>,
8428        group: Option<&'a str>,
8429        fs: &'a str,
8430        remote: &'a str,
8431    ) -> Result<
8432        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8433        Error<types::RcError>,
8434    > {
8435        let url = format!("{}/operations/deletefile", self.baseurl,);
8436        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8437        header_map.append(
8438            ::reqwest::header::HeaderName::from_static("api-version"),
8439            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8440        );
8441        #[allow(unused_mut)]
8442        let mut request = self
8443            .client
8444            .post(url)
8445            .header(
8446                ::reqwest::header::ACCEPT,
8447                ::reqwest::header::HeaderValue::from_static("application/json"),
8448            )
8449            .query(&progenitor_client::QueryParam::new("_async", &async_))
8450            .query(&progenitor_client::QueryParam::new("_group", &group))
8451            .query(&progenitor_client::QueryParam::new("fs", &fs))
8452            .query(&progenitor_client::QueryParam::new("remote", &remote))
8453            .headers(header_map)
8454            .build()?;
8455        let info = OperationInfo {
8456            operation_id: "operations_deletefile",
8457        };
8458        self.pre(&mut request, &info).await?;
8459        let result = self.exec(request, &info).await;
8460        self.post(&result, &info).await?;
8461        let response = result?;
8462        match response.status().as_u16() {
8463            200u16 => ResponseValue::from_response(response).await,
8464            400u16..=499u16 => Err(Error::ErrorResponse(
8465                ResponseValue::from_response(response).await?,
8466            )),
8467            500u16..=599u16 => Err(Error::ErrorResponse(
8468                ResponseValue::from_response(response).await?,
8469            )),
8470            _ => Err(Error::UnexpectedResponse(response)),
8471        }
8472    }
8473
8474    ///Describe remote capabilities
8475    ///
8476    ///Returns backend features, hash support, metadata descriptions, and other
8477    /// info for the remote.
8478    ///
8479    ///Sends a `POST` request to `/operations/fsinfo`
8480    ///
8481    ///Arguments:
8482    /// - `async_`: Run the command asynchronously. Returns a job id
8483    ///   immediately.
8484    /// - `group`: Assign the request to a custom stats group.
8485    /// - `fs`: Remote name or path to inspect, e.g. `drive:`.
8486    pub async fn operations_fsinfo<'a>(
8487        &'a self,
8488        async_: Option<bool>,
8489        group: Option<&'a str>,
8490        fs: &'a str,
8491    ) -> Result<ResponseValue<types::OperationsFsinfoResponse>, Error<types::RcError>> {
8492        let url = format!("{}/operations/fsinfo", self.baseurl,);
8493        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8494        header_map.append(
8495            ::reqwest::header::HeaderName::from_static("api-version"),
8496            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8497        );
8498        #[allow(unused_mut)]
8499        let mut request = self
8500            .client
8501            .post(url)
8502            .header(
8503                ::reqwest::header::ACCEPT,
8504                ::reqwest::header::HeaderValue::from_static("application/json"),
8505            )
8506            .query(&progenitor_client::QueryParam::new("_async", &async_))
8507            .query(&progenitor_client::QueryParam::new("_group", &group))
8508            .query(&progenitor_client::QueryParam::new("fs", &fs))
8509            .headers(header_map)
8510            .build()?;
8511        let info = OperationInfo {
8512            operation_id: "operations_fsinfo",
8513        };
8514        self.pre(&mut request, &info).await?;
8515        let result = self.exec(request, &info).await;
8516        self.post(&result, &info).await?;
8517        let response = result?;
8518        match response.status().as_u16() {
8519            200u16 => ResponseValue::from_response(response).await,
8520            400u16..=499u16 => Err(Error::ErrorResponse(
8521                ResponseValue::from_response(response).await?,
8522            )),
8523            500u16..=599u16 => Err(Error::ErrorResponse(
8524                ResponseValue::from_response(response).await?,
8525            )),
8526            _ => Err(Error::UnexpectedResponse(response)),
8527        }
8528    }
8529
8530    ///Generate hash sums
8531    ///
8532    ///Produces a hash sum listing for files under the given path using the
8533    /// requested hash algorithm.
8534    ///
8535    ///Sends a `POST` request to `/operations/hashsum`
8536    ///
8537    ///Arguments:
8538    /// - `async_`: Run the command asynchronously. Returns a job id
8539    ///   immediately.
8540    /// - `group`: Assign the request to a custom stats group.
8541    /// - `base64`: Set to true to emit hash values in base64 rather than
8542    ///   hexadecimal.
8543    /// - `download`: Set to true to force reading the data instead of using
8544    ///   remote checksums.
8545    /// - `fs`: Remote name or path to hash, such as `drive:` or `/`.
8546    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
8547    ///   supported name.
8548    pub async fn operations_hashsum<'a>(
8549        &'a self,
8550        async_: Option<bool>,
8551        group: Option<&'a str>,
8552        base64: Option<bool>,
8553        download: Option<bool>,
8554        fs: &'a str,
8555        hash_type: &'a str,
8556    ) -> Result<ResponseValue<types::OperationsHashsumResponse>, Error<types::RcError>> {
8557        let url = format!("{}/operations/hashsum", self.baseurl,);
8558        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8559        header_map.append(
8560            ::reqwest::header::HeaderName::from_static("api-version"),
8561            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8562        );
8563        #[allow(unused_mut)]
8564        let mut request = self
8565            .client
8566            .post(url)
8567            .header(
8568                ::reqwest::header::ACCEPT,
8569                ::reqwest::header::HeaderValue::from_static("application/json"),
8570            )
8571            .query(&progenitor_client::QueryParam::new("_async", &async_))
8572            .query(&progenitor_client::QueryParam::new("_group", &group))
8573            .query(&progenitor_client::QueryParam::new("base64", &base64))
8574            .query(&progenitor_client::QueryParam::new("download", &download))
8575            .query(&progenitor_client::QueryParam::new("fs", &fs))
8576            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
8577            .headers(header_map)
8578            .build()?;
8579        let info = OperationInfo {
8580            operation_id: "operations_hashsum",
8581        };
8582        self.pre(&mut request, &info).await?;
8583        let result = self.exec(request, &info).await;
8584        self.post(&result, &info).await?;
8585        let response = result?;
8586        match response.status().as_u16() {
8587            200u16 => ResponseValue::from_response(response).await,
8588            400u16..=499u16 => Err(Error::ErrorResponse(
8589                ResponseValue::from_response(response).await?,
8590            )),
8591            500u16..=599u16 => Err(Error::ErrorResponse(
8592                ResponseValue::from_response(response).await?,
8593            )),
8594            _ => Err(Error::UnexpectedResponse(response)),
8595        }
8596    }
8597
8598    ///Hash a single file
8599    ///
8600    ///Returns the hash of a single file using the specified hash algorithm.
8601    ///
8602    ///Sends a `POST` request to `/operations/hashsumfile`
8603    ///
8604    ///Arguments:
8605    /// - `async_`: Run the command asynchronously. Returns a job id
8606    ///   immediately.
8607    /// - `group`: Assign the request to a custom stats group.
8608    /// - `base64`: Set to true to emit the hash value in base64 rather than
8609    ///   hexadecimal.
8610    /// - `download`: Set to true to force reading the data instead of using
8611    ///   remote checksums.
8612    /// - `fs`: Remote name or path containing the file to hash.
8613    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
8614    ///   supported name.
8615    /// - `remote`: Path to the specific file within `fs` to hash.
8616    pub async fn operations_hashsumfile<'a>(
8617        &'a self,
8618        async_: Option<bool>,
8619        group: Option<&'a str>,
8620        base64: Option<bool>,
8621        download: Option<bool>,
8622        fs: &'a str,
8623        hash_type: &'a str,
8624        remote: &'a str,
8625    ) -> Result<ResponseValue<types::OperationsHashsumfileResponse>, Error<types::RcError>> {
8626        let url = format!("{}/operations/hashsumfile", self.baseurl,);
8627        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8628        header_map.append(
8629            ::reqwest::header::HeaderName::from_static("api-version"),
8630            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8631        );
8632        #[allow(unused_mut)]
8633        let mut request = self
8634            .client
8635            .post(url)
8636            .header(
8637                ::reqwest::header::ACCEPT,
8638                ::reqwest::header::HeaderValue::from_static("application/json"),
8639            )
8640            .query(&progenitor_client::QueryParam::new("_async", &async_))
8641            .query(&progenitor_client::QueryParam::new("_group", &group))
8642            .query(&progenitor_client::QueryParam::new("base64", &base64))
8643            .query(&progenitor_client::QueryParam::new("download", &download))
8644            .query(&progenitor_client::QueryParam::new("fs", &fs))
8645            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
8646            .query(&progenitor_client::QueryParam::new("remote", &remote))
8647            .headers(header_map)
8648            .build()?;
8649        let info = OperationInfo {
8650            operation_id: "operations_hashsumfile",
8651        };
8652        self.pre(&mut request, &info).await?;
8653        let result = self.exec(request, &info).await;
8654        self.post(&result, &info).await?;
8655        let response = result?;
8656        match response.status().as_u16() {
8657            200u16 => ResponseValue::from_response(response).await,
8658            400u16..=499u16 => Err(Error::ErrorResponse(
8659                ResponseValue::from_response(response).await?,
8660            )),
8661            500u16..=599u16 => Err(Error::ErrorResponse(
8662                ResponseValue::from_response(response).await?,
8663            )),
8664            _ => Err(Error::UnexpectedResponse(response)),
8665        }
8666    }
8667
8668    ///Move a single file
8669    ///
8670    ///Moves one object from a source remote and path to a destination remote
8671    /// and path.
8672    ///
8673    ///Sends a `POST` request to `/operations/movefile`
8674    ///
8675    ///Arguments:
8676    /// - `async_`: Run the command asynchronously. Returns a job id
8677    ///   immediately.
8678    /// - `group`: Assign the request to a custom stats group.
8679    /// - `dst_fs`: Destination remote name or path where the file will be
8680    ///   moved.
8681    /// - `dst_remote`: Destination path within `dstFs` for the moved object.
8682    /// - `src_fs`: Source remote name or path containing the file to move.
8683    /// - `src_remote`: Path to the source object within `srcFs`.
8684    pub async fn operations_movefile<'a>(
8685        &'a self,
8686        async_: Option<bool>,
8687        group: Option<&'a str>,
8688        dst_fs: &'a str,
8689        dst_remote: &'a str,
8690        src_fs: &'a str,
8691        src_remote: &'a str,
8692    ) -> Result<
8693        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8694        Error<types::RcError>,
8695    > {
8696        let url = format!("{}/operations/movefile", self.baseurl,);
8697        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8698        header_map.append(
8699            ::reqwest::header::HeaderName::from_static("api-version"),
8700            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8701        );
8702        #[allow(unused_mut)]
8703        let mut request = self
8704            .client
8705            .post(url)
8706            .header(
8707                ::reqwest::header::ACCEPT,
8708                ::reqwest::header::HeaderValue::from_static("application/json"),
8709            )
8710            .query(&progenitor_client::QueryParam::new("_async", &async_))
8711            .query(&progenitor_client::QueryParam::new("_group", &group))
8712            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
8713            .query(&progenitor_client::QueryParam::new(
8714                "dstRemote",
8715                &dst_remote,
8716            ))
8717            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
8718            .query(&progenitor_client::QueryParam::new(
8719                "srcRemote",
8720                &src_remote,
8721            ))
8722            .headers(header_map)
8723            .build()?;
8724        let info = OperationInfo {
8725            operation_id: "operations_movefile",
8726        };
8727        self.pre(&mut request, &info).await?;
8728        let result = self.exec(request, &info).await;
8729        self.post(&result, &info).await?;
8730        let response = result?;
8731        match response.status().as_u16() {
8732            200u16 => ResponseValue::from_response(response).await,
8733            400u16..=499u16 => Err(Error::ErrorResponse(
8734                ResponseValue::from_response(response).await?,
8735            )),
8736            500u16..=599u16 => Err(Error::ErrorResponse(
8737                ResponseValue::from_response(response).await?,
8738            )),
8739            _ => Err(Error::UnexpectedResponse(response)),
8740        }
8741    }
8742
8743    ///Create or remove public link
8744    ///
8745    ///Creates a share URL for an object or removes an existing link when
8746    /// `unlink=true`.
8747    ///
8748    ///Sends a `POST` request to `/operations/publiclink`
8749    ///
8750    ///Arguments:
8751    /// - `async_`: Run the command asynchronously. Returns a job id
8752    ///   immediately.
8753    /// - `group`: Assign the request to a custom stats group.
8754    /// - `expire`: Optional expiration time for the public link, formatted as
8755    ///   supported by the backend.
8756    /// - `fs`: Remote name or path hosting the object for which to manage a
8757    ///   public link.
8758    /// - `remote`: Path within `fs` to the object for which to create or remove
8759    ///   a public link.
8760    /// - `unlink`: Set to true to remove an existing public link instead of
8761    ///   creating one.
8762    pub async fn operations_publiclink<'a>(
8763        &'a self,
8764        async_: Option<bool>,
8765        group: Option<&'a str>,
8766        expire: Option<&'a str>,
8767        fs: &'a str,
8768        remote: &'a str,
8769        unlink: Option<bool>,
8770    ) -> Result<ResponseValue<types::OperationsPubliclinkResponse>, Error<types::RcError>> {
8771        let url = format!("{}/operations/publiclink", self.baseurl,);
8772        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8773        header_map.append(
8774            ::reqwest::header::HeaderName::from_static("api-version"),
8775            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8776        );
8777        #[allow(unused_mut)]
8778        let mut request = self
8779            .client
8780            .post(url)
8781            .header(
8782                ::reqwest::header::ACCEPT,
8783                ::reqwest::header::HeaderValue::from_static("application/json"),
8784            )
8785            .query(&progenitor_client::QueryParam::new("_async", &async_))
8786            .query(&progenitor_client::QueryParam::new("_group", &group))
8787            .query(&progenitor_client::QueryParam::new("expire", &expire))
8788            .query(&progenitor_client::QueryParam::new("fs", &fs))
8789            .query(&progenitor_client::QueryParam::new("remote", &remote))
8790            .query(&progenitor_client::QueryParam::new("unlink", &unlink))
8791            .headers(header_map)
8792            .build()?;
8793        let info = OperationInfo {
8794            operation_id: "operations_publiclink",
8795        };
8796        self.pre(&mut request, &info).await?;
8797        let result = self.exec(request, &info).await;
8798        self.post(&result, &info).await?;
8799        let response = result?;
8800        match response.status().as_u16() {
8801            200u16 => ResponseValue::from_response(response).await,
8802            400u16..=499u16 => Err(Error::ErrorResponse(
8803                ResponseValue::from_response(response).await?,
8804            )),
8805            500u16..=599u16 => Err(Error::ErrorResponse(
8806                ResponseValue::from_response(response).await?,
8807            )),
8808            _ => Err(Error::UnexpectedResponse(response)),
8809        }
8810    }
8811
8812    ///Remove empty directories
8813    ///
8814    ///Deletes empty subdirectories beneath the specified path, optionally
8815    /// leaving the root.
8816    ///
8817    ///Sends a `POST` request to `/operations/rmdirs`
8818    ///
8819    ///Arguments:
8820    /// - `async_`: Run the command asynchronously. Returns a job id
8821    ///   immediately.
8822    /// - `group`: Assign the request to a custom stats group.
8823    /// - `fs`: Remote name or path to scan for empty directories.
8824    /// - `leave_root`: Set to true to preserve the top-level directory even if
8825    ///   empty.
8826    /// - `remote`: Path within `fs` whose empty subdirectories should be
8827    ///   removed.
8828    pub async fn operations_rmdirs<'a>(
8829        &'a self,
8830        async_: Option<bool>,
8831        group: Option<&'a str>,
8832        fs: &'a str,
8833        leave_root: Option<bool>,
8834        remote: &'a str,
8835    ) -> Result<
8836        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8837        Error<types::RcError>,
8838    > {
8839        let url = format!("{}/operations/rmdirs", self.baseurl,);
8840        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8841        header_map.append(
8842            ::reqwest::header::HeaderName::from_static("api-version"),
8843            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8844        );
8845        #[allow(unused_mut)]
8846        let mut request = self
8847            .client
8848            .post(url)
8849            .header(
8850                ::reqwest::header::ACCEPT,
8851                ::reqwest::header::HeaderValue::from_static("application/json"),
8852            )
8853            .query(&progenitor_client::QueryParam::new("_async", &async_))
8854            .query(&progenitor_client::QueryParam::new("_group", &group))
8855            .query(&progenitor_client::QueryParam::new("fs", &fs))
8856            .query(&progenitor_client::QueryParam::new(
8857                "leaveRoot",
8858                &leave_root,
8859            ))
8860            .query(&progenitor_client::QueryParam::new("remote", &remote))
8861            .headers(header_map)
8862            .build()?;
8863        let info = OperationInfo {
8864            operation_id: "operations_rmdirs",
8865        };
8866        self.pre(&mut request, &info).await?;
8867        let result = self.exec(request, &info).await;
8868        self.post(&result, &info).await?;
8869        let response = result?;
8870        match response.status().as_u16() {
8871            200u16 => ResponseValue::from_response(response).await,
8872            400u16..=499u16 => Err(Error::ErrorResponse(
8873                ResponseValue::from_response(response).await?,
8874            )),
8875            500u16..=599u16 => Err(Error::ErrorResponse(
8876                ResponseValue::from_response(response).await?,
8877            )),
8878            _ => Err(Error::UnexpectedResponse(response)),
8879        }
8880    }
8881
8882    ///Change storage tier
8883    ///
8884    ///Updates the storage class or tier for every object in the specified
8885    /// remote path.
8886    ///
8887    ///Sends a `POST` request to `/operations/settier`
8888    ///
8889    ///Arguments:
8890    /// - `async_`: Run the command asynchronously. Returns a job id
8891    ///   immediately.
8892    /// - `group`: Assign the request to a custom stats group.
8893    /// - `fs`: Remote name or path whose storage class tier should be changed.
8894    pub async fn operations_settier<'a>(
8895        &'a self,
8896        async_: Option<bool>,
8897        group: Option<&'a str>,
8898        fs: &'a str,
8899    ) -> Result<
8900        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8901        Error<types::RcError>,
8902    > {
8903        let url = format!("{}/operations/settier", self.baseurl,);
8904        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8905        header_map.append(
8906            ::reqwest::header::HeaderName::from_static("api-version"),
8907            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8908        );
8909        #[allow(unused_mut)]
8910        let mut request = self
8911            .client
8912            .post(url)
8913            .header(
8914                ::reqwest::header::ACCEPT,
8915                ::reqwest::header::HeaderValue::from_static("application/json"),
8916            )
8917            .query(&progenitor_client::QueryParam::new("_async", &async_))
8918            .query(&progenitor_client::QueryParam::new("_group", &group))
8919            .query(&progenitor_client::QueryParam::new("fs", &fs))
8920            .headers(header_map)
8921            .build()?;
8922        let info = OperationInfo {
8923            operation_id: "operations_settier",
8924        };
8925        self.pre(&mut request, &info).await?;
8926        let result = self.exec(request, &info).await;
8927        self.post(&result, &info).await?;
8928        let response = result?;
8929        match response.status().as_u16() {
8930            200u16 => ResponseValue::from_response(response).await,
8931            400u16..=499u16 => Err(Error::ErrorResponse(
8932                ResponseValue::from_response(response).await?,
8933            )),
8934            500u16..=599u16 => Err(Error::ErrorResponse(
8935                ResponseValue::from_response(response).await?,
8936            )),
8937            _ => Err(Error::UnexpectedResponse(response)),
8938        }
8939    }
8940
8941    ///Change file storage tier
8942    ///
8943    ///Updates the storage class or tier for a single object.
8944    ///
8945    ///Sends a `POST` request to `/operations/settierfile`
8946    ///
8947    ///Arguments:
8948    /// - `async_`: Run the command asynchronously. Returns a job id
8949    ///   immediately.
8950    /// - `group`: Assign the request to a custom stats group.
8951    /// - `fs`: Remote name or path that contains the object whose tier should
8952    ///   change.
8953    /// - `remote`: Path within `fs` to the object whose storage class tier
8954    ///   should be updated.
8955    pub async fn operations_settierfile<'a>(
8956        &'a self,
8957        async_: Option<bool>,
8958        group: Option<&'a str>,
8959        fs: &'a str,
8960        remote: &'a str,
8961    ) -> Result<
8962        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8963        Error<types::RcError>,
8964    > {
8965        let url = format!("{}/operations/settierfile", self.baseurl,);
8966        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8967        header_map.append(
8968            ::reqwest::header::HeaderName::from_static("api-version"),
8969            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8970        );
8971        #[allow(unused_mut)]
8972        let mut request = self
8973            .client
8974            .post(url)
8975            .header(
8976                ::reqwest::header::ACCEPT,
8977                ::reqwest::header::HeaderValue::from_static("application/json"),
8978            )
8979            .query(&progenitor_client::QueryParam::new("_async", &async_))
8980            .query(&progenitor_client::QueryParam::new("_group", &group))
8981            .query(&progenitor_client::QueryParam::new("fs", &fs))
8982            .query(&progenitor_client::QueryParam::new("remote", &remote))
8983            .headers(header_map)
8984            .build()?;
8985        let info = OperationInfo {
8986            operation_id: "operations_settierfile",
8987        };
8988        self.pre(&mut request, &info).await?;
8989        let result = self.exec(request, &info).await;
8990        self.post(&result, &info).await?;
8991        let response = result?;
8992        match response.status().as_u16() {
8993            200u16 => ResponseValue::from_response(response).await,
8994            400u16..=499u16 => Err(Error::ErrorResponse(
8995                ResponseValue::from_response(response).await?,
8996            )),
8997            500u16..=599u16 => Err(Error::ErrorResponse(
8998                ResponseValue::from_response(response).await?,
8999            )),
9000            _ => Err(Error::UnexpectedResponse(response)),
9001        }
9002    }
9003
9004    ///Count remote size
9005    ///
9006    ///Reports total size, file count, and number of objects without size
9007    /// metadata.
9008    ///
9009    ///Sends a `POST` request to `/operations/size`
9010    ///
9011    ///Arguments:
9012    /// - `async_`: Run the command asynchronously. Returns a job id
9013    ///   immediately.
9014    /// - `group`: Assign the request to a custom stats group.
9015    /// - `fs`: Remote name or path to measure aggregate size information for.
9016    pub async fn operations_size<'a>(
9017        &'a self,
9018        async_: Option<bool>,
9019        group: Option<&'a str>,
9020        fs: &'a str,
9021    ) -> Result<ResponseValue<types::OperationsSizeResponse>, Error<types::RcError>> {
9022        let url = format!("{}/operations/size", self.baseurl,);
9023        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9024        header_map.append(
9025            ::reqwest::header::HeaderName::from_static("api-version"),
9026            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9027        );
9028        #[allow(unused_mut)]
9029        let mut request = self
9030            .client
9031            .post(url)
9032            .header(
9033                ::reqwest::header::ACCEPT,
9034                ::reqwest::header::HeaderValue::from_static("application/json"),
9035            )
9036            .query(&progenitor_client::QueryParam::new("_async", &async_))
9037            .query(&progenitor_client::QueryParam::new("_group", &group))
9038            .query(&progenitor_client::QueryParam::new("fs", &fs))
9039            .headers(header_map)
9040            .build()?;
9041        let info = OperationInfo {
9042            operation_id: "operations_size",
9043        };
9044        self.pre(&mut request, &info).await?;
9045        let result = self.exec(request, &info).await;
9046        self.post(&result, &info).await?;
9047        let response = result?;
9048        match response.status().as_u16() {
9049            200u16 => ResponseValue::from_response(response).await,
9050            400u16..=499u16 => Err(Error::ErrorResponse(
9051                ResponseValue::from_response(response).await?,
9052            )),
9053            500u16..=599u16 => Err(Error::ErrorResponse(
9054                ResponseValue::from_response(response).await?,
9055            )),
9056            _ => Err(Error::UnexpectedResponse(response)),
9057        }
9058    }
9059
9060    ///Get or update bandwidth limits
9061    ///
9062    ///Reads the current bandwidth limit or applies a new schedule string, just
9063    /// like `rclone rc core/bwlimit`.
9064    ///
9065    ///Sends a `POST` request to `/core/bwlimit`
9066    ///
9067    ///Arguments:
9068    /// - `async_`: Run the command asynchronously. Returns a job id
9069    ///   immediately.
9070    /// - `group`: Assign the request to a custom stats group.
9071    /// - `rate`: Bandwidth limit to apply, for example `off`, `5M`, or a
9072    ///   schedule string.
9073    pub async fn core_bwlimit<'a>(
9074        &'a self,
9075        async_: Option<bool>,
9076        group: Option<&'a str>,
9077        rate: Option<&'a str>,
9078    ) -> Result<ResponseValue<types::CoreBwlimitResponse>, Error<types::RcError>> {
9079        let url = format!("{}/core/bwlimit", self.baseurl,);
9080        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9081        header_map.append(
9082            ::reqwest::header::HeaderName::from_static("api-version"),
9083            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9084        );
9085        #[allow(unused_mut)]
9086        let mut request = self
9087            .client
9088            .post(url)
9089            .header(
9090                ::reqwest::header::ACCEPT,
9091                ::reqwest::header::HeaderValue::from_static("application/json"),
9092            )
9093            .query(&progenitor_client::QueryParam::new("_async", &async_))
9094            .query(&progenitor_client::QueryParam::new("_group", &group))
9095            .query(&progenitor_client::QueryParam::new("rate", &rate))
9096            .headers(header_map)
9097            .build()?;
9098        let info = OperationInfo {
9099            operation_id: "core_bwlimit",
9100        };
9101        self.pre(&mut request, &info).await?;
9102        let result = self.exec(request, &info).await;
9103        self.post(&result, &info).await?;
9104        let response = result?;
9105        match response.status().as_u16() {
9106            200u16 => ResponseValue::from_response(response).await,
9107            400u16..=499u16 => Err(Error::ErrorResponse(
9108                ResponseValue::from_response(response).await?,
9109            )),
9110            500u16..=599u16 => Err(Error::ErrorResponse(
9111                ResponseValue::from_response(response).await?,
9112            )),
9113            _ => Err(Error::UnexpectedResponse(response)),
9114        }
9115    }
9116
9117    ///Run an rclone command
9118    ///
9119    ///Executes a standard rclone CLI command remotely and streams or returns
9120    /// its output.
9121    ///
9122    ///Sends a `POST` request to `/core/command`
9123    ///
9124    ///Arguments:
9125    /// - `async_`: Run the command asynchronously. Returns a job id
9126    ///   immediately.
9127    /// - `group`: Assign the request to a custom stats group.
9128    /// - `arg`: Optional positional arguments for the command. Repeat to supply
9129    ///   multiple values.
9130    /// - `command`: Name of the rclone command to execute, for example `ls` or
9131    ///   `lsf`.
9132    /// - `opt`: Optional command options encoded as a JSON string.
9133    /// - `return_type`: Controls how output is returned; accepts
9134    ///   `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
9135    ///   `STREAM_ONLY_STDERR`.
9136    pub async fn core_command<'a>(
9137        &'a self,
9138        async_: Option<bool>,
9139        group: Option<&'a str>,
9140        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
9141        command: &'a str,
9142        opt: Option<&'a str>,
9143        return_type: Option<&'a str>,
9144    ) -> Result<ResponseValue<types::CoreCommandResponse>, Error<types::RcError>> {
9145        let url = format!("{}/core/command", self.baseurl,);
9146        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9147        header_map.append(
9148            ::reqwest::header::HeaderName::from_static("api-version"),
9149            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9150        );
9151        #[allow(unused_mut)]
9152        let mut request = self
9153            .client
9154            .post(url)
9155            .header(
9156                ::reqwest::header::ACCEPT,
9157                ::reqwest::header::HeaderValue::from_static("application/json"),
9158            )
9159            .query(&progenitor_client::QueryParam::new("_async", &async_))
9160            .query(&progenitor_client::QueryParam::new("_group", &group))
9161            .query(&progenitor_client::QueryParam::new("arg", &arg))
9162            .query(&progenitor_client::QueryParam::new("command", &command))
9163            .query(&progenitor_client::QueryParam::new("opt", &opt))
9164            .query(&progenitor_client::QueryParam::new(
9165                "returnType",
9166                &return_type,
9167            ))
9168            .headers(header_map)
9169            .build()?;
9170        let info = OperationInfo {
9171            operation_id: "core_command",
9172        };
9173        self.pre(&mut request, &info).await?;
9174        let result = self.exec(request, &info).await;
9175        self.post(&result, &info).await?;
9176        let response = result?;
9177        match response.status().as_u16() {
9178            200u16 => ResponseValue::from_response(response).await,
9179            400u16..=499u16 => Err(Error::ErrorResponse(
9180                ResponseValue::from_response(response).await?,
9181            )),
9182            500u16..=599u16 => Err(Error::ErrorResponse(
9183                ResponseValue::from_response(response).await?,
9184            )),
9185            _ => Err(Error::UnexpectedResponse(response)),
9186        }
9187    }
9188
9189    ///Report disk usage
9190    ///
9191    ///Returns disk usage statistics for the supplied local directory (defaults
9192    /// to the cache dir).
9193    ///
9194    ///Sends a `POST` request to `/core/du`
9195    ///
9196    ///Arguments:
9197    /// - `async_`: Run the command asynchronously. Returns a job id
9198    ///   immediately.
9199    /// - `group`: Assign the request to a custom stats group.
9200    /// - `dir`: Local directory path to report disk usage for. Defaults to the
9201    ///   rclone cache directory when omitted.
9202    pub async fn core_du<'a>(
9203        &'a self,
9204        async_: Option<bool>,
9205        group: Option<&'a str>,
9206        dir: Option<&'a str>,
9207    ) -> Result<ResponseValue<types::CoreDuResponse>, Error<types::RcError>> {
9208        let url = format!("{}/core/du", self.baseurl,);
9209        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9210        header_map.append(
9211            ::reqwest::header::HeaderName::from_static("api-version"),
9212            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9213        );
9214        #[allow(unused_mut)]
9215        let mut request = self
9216            .client
9217            .post(url)
9218            .header(
9219                ::reqwest::header::ACCEPT,
9220                ::reqwest::header::HeaderValue::from_static("application/json"),
9221            )
9222            .query(&progenitor_client::QueryParam::new("_async", &async_))
9223            .query(&progenitor_client::QueryParam::new("_group", &group))
9224            .query(&progenitor_client::QueryParam::new("dir", &dir))
9225            .headers(header_map)
9226            .build()?;
9227        let info = OperationInfo {
9228            operation_id: "core_du",
9229        };
9230        self.pre(&mut request, &info).await?;
9231        let result = self.exec(request, &info).await;
9232        self.post(&result, &info).await?;
9233        let response = result?;
9234        match response.status().as_u16() {
9235            200u16 => ResponseValue::from_response(response).await,
9236            400u16..=499u16 => Err(Error::ErrorResponse(
9237                ResponseValue::from_response(response).await?,
9238            )),
9239            500u16..=599u16 => Err(Error::ErrorResponse(
9240                ResponseValue::from_response(response).await?,
9241            )),
9242            _ => Err(Error::UnexpectedResponse(response)),
9243        }
9244    }
9245
9246    ///Force garbage collection
9247    ///
9248    ///Triggers Go's garbage collector to release unused memory.
9249    ///
9250    ///Sends a `POST` request to `/core/gc`
9251    ///
9252    ///Arguments:
9253    /// - `async_`: Run the command asynchronously. Returns a job id
9254    ///   immediately.
9255    /// - `group`: Assign the request to a custom stats group.
9256    pub async fn core_gc<'a>(
9257        &'a self,
9258        async_: Option<bool>,
9259        group: Option<&'a str>,
9260    ) -> Result<
9261        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9262        Error<types::RcError>,
9263    > {
9264        let url = format!("{}/core/gc", self.baseurl,);
9265        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9266        header_map.append(
9267            ::reqwest::header::HeaderName::from_static("api-version"),
9268            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9269        );
9270        #[allow(unused_mut)]
9271        let mut request = self
9272            .client
9273            .post(url)
9274            .header(
9275                ::reqwest::header::ACCEPT,
9276                ::reqwest::header::HeaderValue::from_static("application/json"),
9277            )
9278            .query(&progenitor_client::QueryParam::new("_async", &async_))
9279            .query(&progenitor_client::QueryParam::new("_group", &group))
9280            .headers(header_map)
9281            .build()?;
9282        let info = OperationInfo {
9283            operation_id: "core_gc",
9284        };
9285        self.pre(&mut request, &info).await?;
9286        let result = self.exec(request, &info).await;
9287        self.post(&result, &info).await?;
9288        let response = result?;
9289        match response.status().as_u16() {
9290            200u16 => ResponseValue::from_response(response).await,
9291            400u16..=499u16 => Err(Error::ErrorResponse(
9292                ResponseValue::from_response(response).await?,
9293            )),
9294            500u16..=599u16 => Err(Error::ErrorResponse(
9295                ResponseValue::from_response(response).await?,
9296            )),
9297            _ => Err(Error::UnexpectedResponse(response)),
9298        }
9299    }
9300
9301    ///List stats groups
9302    ///
9303    ///Lists stats groups currently tracked by rclone.
9304    ///
9305    ///Sends a `POST` request to `/core/group-list`
9306    ///
9307    ///Arguments:
9308    /// - `async_`: Run the command asynchronously. Returns a job id
9309    ///   immediately.
9310    /// - `group`: Assign the request to a custom stats group.
9311    pub async fn core_group_list<'a>(
9312        &'a self,
9313        async_: Option<bool>,
9314        group: Option<&'a str>,
9315    ) -> Result<ResponseValue<types::CoreGroupListResponse>, Error<types::RcError>> {
9316        let url = format!("{}/core/group-list", self.baseurl,);
9317        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9318        header_map.append(
9319            ::reqwest::header::HeaderName::from_static("api-version"),
9320            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9321        );
9322        #[allow(unused_mut)]
9323        let mut request = self
9324            .client
9325            .post(url)
9326            .header(
9327                ::reqwest::header::ACCEPT,
9328                ::reqwest::header::HeaderValue::from_static("application/json"),
9329            )
9330            .query(&progenitor_client::QueryParam::new("_async", &async_))
9331            .query(&progenitor_client::QueryParam::new("_group", &group))
9332            .headers(header_map)
9333            .build()?;
9334        let info = OperationInfo {
9335            operation_id: "core_group_list",
9336        };
9337        self.pre(&mut request, &info).await?;
9338        let result = self.exec(request, &info).await;
9339        self.post(&result, &info).await?;
9340        let response = result?;
9341        match response.status().as_u16() {
9342            200u16 => ResponseValue::from_response(response).await,
9343            400u16..=499u16 => Err(Error::ErrorResponse(
9344                ResponseValue::from_response(response).await?,
9345            )),
9346            500u16..=599u16 => Err(Error::ErrorResponse(
9347                ResponseValue::from_response(response).await?,
9348            )),
9349            _ => Err(Error::UnexpectedResponse(response)),
9350        }
9351    }
9352
9353    ///Fetch runtime memory stats
9354    ///
9355    ///Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
9356    ///
9357    ///Sends a `POST` request to `/core/memstats`
9358    ///
9359    ///Arguments:
9360    /// - `async_`: Run the command asynchronously. Returns a job id
9361    ///   immediately.
9362    /// - `group`: Assign the request to a custom stats group.
9363    pub async fn core_memstats<'a>(
9364        &'a self,
9365        async_: Option<bool>,
9366        group: Option<&'a str>,
9367    ) -> Result<
9368        ResponseValue<::std::collections::HashMap<::std::string::String, f64>>,
9369        Error<types::RcError>,
9370    > {
9371        let url = format!("{}/core/memstats", self.baseurl,);
9372        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9373        header_map.append(
9374            ::reqwest::header::HeaderName::from_static("api-version"),
9375            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9376        );
9377        #[allow(unused_mut)]
9378        let mut request = self
9379            .client
9380            .post(url)
9381            .header(
9382                ::reqwest::header::ACCEPT,
9383                ::reqwest::header::HeaderValue::from_static("application/json"),
9384            )
9385            .query(&progenitor_client::QueryParam::new("_async", &async_))
9386            .query(&progenitor_client::QueryParam::new("_group", &group))
9387            .headers(header_map)
9388            .build()?;
9389        let info = OperationInfo {
9390            operation_id: "core_memstats",
9391        };
9392        self.pre(&mut request, &info).await?;
9393        let result = self.exec(request, &info).await;
9394        self.post(&result, &info).await?;
9395        let response = result?;
9396        match response.status().as_u16() {
9397            200u16 => ResponseValue::from_response(response).await,
9398            400u16..=499u16 => Err(Error::ErrorResponse(
9399                ResponseValue::from_response(response).await?,
9400            )),
9401            500u16..=599u16 => Err(Error::ErrorResponse(
9402                ResponseValue::from_response(response).await?,
9403            )),
9404            _ => Err(Error::UnexpectedResponse(response)),
9405        }
9406    }
9407
9408    ///Obscure a clear string
9409    ///
9410    ///Obscures a plain-text secret for inclusion in `rclone.conf`.
9411    ///
9412    ///Sends a `POST` request to `/core/obscure`
9413    ///
9414    ///Arguments:
9415    /// - `async_`: Run the command asynchronously. Returns a job id
9416    ///   immediately.
9417    /// - `group`: Assign the request to a custom stats group.
9418    /// - `clear`: Plain-text string to obscure for storage in the config file.
9419    pub async fn core_obscure<'a>(
9420        &'a self,
9421        async_: Option<bool>,
9422        group: Option<&'a str>,
9423        clear: &'a str,
9424    ) -> Result<ResponseValue<types::CoreObscureResponse>, Error<types::RcError>> {
9425        let url = format!("{}/core/obscure", self.baseurl,);
9426        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9427        header_map.append(
9428            ::reqwest::header::HeaderName::from_static("api-version"),
9429            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9430        );
9431        #[allow(unused_mut)]
9432        let mut request = self
9433            .client
9434            .post(url)
9435            .header(
9436                ::reqwest::header::ACCEPT,
9437                ::reqwest::header::HeaderValue::from_static("application/json"),
9438            )
9439            .query(&progenitor_client::QueryParam::new("_async", &async_))
9440            .query(&progenitor_client::QueryParam::new("_group", &group))
9441            .query(&progenitor_client::QueryParam::new("clear", &clear))
9442            .headers(header_map)
9443            .build()?;
9444        let info = OperationInfo {
9445            operation_id: "core_obscure",
9446        };
9447        self.pre(&mut request, &info).await?;
9448        let result = self.exec(request, &info).await;
9449        self.post(&result, &info).await?;
9450        let response = result?;
9451        match response.status().as_u16() {
9452            200u16 => ResponseValue::from_response(response).await,
9453            400u16..=499u16 => Err(Error::ErrorResponse(
9454                ResponseValue::from_response(response).await?,
9455            )),
9456            500u16..=599u16 => Err(Error::ErrorResponse(
9457                ResponseValue::from_response(response).await?,
9458            )),
9459            _ => Err(Error::UnexpectedResponse(response)),
9460        }
9461    }
9462
9463    ///Return rclone PID
9464    ///
9465    ///Returns the process ID of the running rclone instance.
9466    ///
9467    ///Sends a `POST` request to `/core/pid`
9468    ///
9469    ///Arguments:
9470    /// - `async_`: Run the command asynchronously. Returns a job id
9471    ///   immediately.
9472    /// - `group`: Assign the request to a custom stats group.
9473    pub async fn core_pid<'a>(
9474        &'a self,
9475        async_: Option<bool>,
9476        group: Option<&'a str>,
9477    ) -> Result<ResponseValue<types::CorePidResponse>, Error<types::RcError>> {
9478        let url = format!("{}/core/pid", self.baseurl,);
9479        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9480        header_map.append(
9481            ::reqwest::header::HeaderName::from_static("api-version"),
9482            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9483        );
9484        #[allow(unused_mut)]
9485        let mut request = self
9486            .client
9487            .post(url)
9488            .header(
9489                ::reqwest::header::ACCEPT,
9490                ::reqwest::header::HeaderValue::from_static("application/json"),
9491            )
9492            .query(&progenitor_client::QueryParam::new("_async", &async_))
9493            .query(&progenitor_client::QueryParam::new("_group", &group))
9494            .headers(header_map)
9495            .build()?;
9496        let info = OperationInfo {
9497            operation_id: "core_pid",
9498        };
9499        self.pre(&mut request, &info).await?;
9500        let result = self.exec(request, &info).await;
9501        self.post(&result, &info).await?;
9502        let response = result?;
9503        match response.status().as_u16() {
9504            200u16 => ResponseValue::from_response(response).await,
9505            400u16..=499u16 => Err(Error::ErrorResponse(
9506                ResponseValue::from_response(response).await?,
9507            )),
9508            500u16..=599u16 => Err(Error::ErrorResponse(
9509                ResponseValue::from_response(response).await?,
9510            )),
9511            _ => Err(Error::UnexpectedResponse(response)),
9512        }
9513    }
9514
9515    ///Terminate rclone
9516    ///
9517    ///Stops the rclone process, optionally supplying an exit code.
9518    ///
9519    ///Sends a `POST` request to `/core/quit`
9520    ///
9521    ///Arguments:
9522    /// - `async_`: Run the command asynchronously. Returns a job id
9523    ///   immediately.
9524    /// - `group`: Assign the request to a custom stats group.
9525    /// - `exit_code`: Optional exit code to use when terminating the rclone
9526    ///   process.
9527    pub async fn core_quit<'a>(
9528        &'a self,
9529        async_: Option<bool>,
9530        group: Option<&'a str>,
9531        exit_code: Option<i64>,
9532    ) -> Result<
9533        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9534        Error<types::RcError>,
9535    > {
9536        let url = format!("{}/core/quit", self.baseurl,);
9537        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9538        header_map.append(
9539            ::reqwest::header::HeaderName::from_static("api-version"),
9540            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9541        );
9542        #[allow(unused_mut)]
9543        let mut request = self
9544            .client
9545            .post(url)
9546            .header(
9547                ::reqwest::header::ACCEPT,
9548                ::reqwest::header::HeaderValue::from_static("application/json"),
9549            )
9550            .query(&progenitor_client::QueryParam::new("_async", &async_))
9551            .query(&progenitor_client::QueryParam::new("_group", &group))
9552            .query(&progenitor_client::QueryParam::new("exitCode", &exit_code))
9553            .headers(header_map)
9554            .build()?;
9555        let info = OperationInfo {
9556            operation_id: "core_quit",
9557        };
9558        self.pre(&mut request, &info).await?;
9559        let result = self.exec(request, &info).await;
9560        self.post(&result, &info).await?;
9561        let response = result?;
9562        match response.status().as_u16() {
9563            200u16 => ResponseValue::from_response(response).await,
9564            400u16..=499u16 => Err(Error::ErrorResponse(
9565                ResponseValue::from_response(response).await?,
9566            )),
9567            500u16..=599u16 => Err(Error::ErrorResponse(
9568                ResponseValue::from_response(response).await?,
9569            )),
9570            _ => Err(Error::UnexpectedResponse(response)),
9571        }
9572    }
9573
9574    ///Delete stats group
9575    ///
9576    ///Deletes the counters associated with a specific stats group.
9577    ///
9578    ///Sends a `POST` request to `/core/stats-delete`
9579    ///
9580    ///Arguments:
9581    /// - `async_`: Run the command asynchronously. Returns a job id
9582    ///   immediately.
9583    /// - `group`: Assign the request to a custom stats group.
9584    /// - `group`: Stats group identifier to remove.
9585    pub async fn core_stats_delete<'a>(
9586        &'a self,
9587        async_: Option<bool>,
9588        _group: Option<&'a str>,
9589        group: &'a str
9590    ) -> Result<
9591        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9592        Error<types::RcError>,
9593    > {
9594        let url = format!("{}/core/stats-delete", self.baseurl,);
9595        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9596        header_map.append(
9597            ::reqwest::header::HeaderName::from_static("api-version"),
9598            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9599        );
9600        #[allow(unused_mut)]
9601        let mut request = self
9602            .client
9603            .post(url)
9604            .header(
9605                ::reqwest::header::ACCEPT,
9606                ::reqwest::header::HeaderValue::from_static("application/json"),
9607            )
9608            .query(&progenitor_client::QueryParam::new("_async", &async_))
9609            .query(&progenitor_client::QueryParam::new("_group", &group))
9610            .query(&progenitor_client::QueryParam::new("group", &group))
9611            .headers(header_map)
9612            .build()?;
9613        let info = OperationInfo {
9614            operation_id: "core_stats_delete",
9615        };
9616        self.pre(&mut request, &info).await?;
9617        let result = self.exec(request, &info).await;
9618        self.post(&result, &info).await?;
9619        let response = result?;
9620        match response.status().as_u16() {
9621            200u16 => ResponseValue::from_response(response).await,
9622            400u16..=499u16 => Err(Error::ErrorResponse(
9623                ResponseValue::from_response(response).await?,
9624            )),
9625            500u16..=599u16 => Err(Error::ErrorResponse(
9626                ResponseValue::from_response(response).await?,
9627            )),
9628            _ => Err(Error::UnexpectedResponse(response)),
9629        }
9630    }
9631
9632    ///Reset stats counters
9633    ///
9634    ///Clears counters, errors, and finished transfers for the provided stats
9635    /// group or all groups.
9636    ///
9637    ///Sends a `POST` request to `/core/stats-reset`
9638    ///
9639    ///Arguments:
9640    /// - `async_`: Run the command asynchronously. Returns a job id
9641    ///   immediately.
9642    /// - `group`: Assign the request to a custom stats group.
9643    /// - `group`: Stats group identifier whose counters should be reset. Leave
9644    ///   unset to reset all groups.
9645    pub async fn core_stats_reset<'a>(
9646        &'a self,
9647        async_: Option<bool>,
9648        _group: Option<&'a str>,
9649        group: Option<&'a str>
9650    ) -> Result<
9651        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9652        Error<types::RcError>,
9653    > {
9654        let url = format!("{}/core/stats-reset", self.baseurl,);
9655        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9656        header_map.append(
9657            ::reqwest::header::HeaderName::from_static("api-version"),
9658            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9659        );
9660        #[allow(unused_mut)]
9661        let mut request = self
9662            .client
9663            .post(url)
9664            .header(
9665                ::reqwest::header::ACCEPT,
9666                ::reqwest::header::HeaderValue::from_static("application/json"),
9667            )
9668            .query(&progenitor_client::QueryParam::new("_async", &async_))
9669            .query(&progenitor_client::QueryParam::new("_group", &group))
9670            .query(&progenitor_client::QueryParam::new("group", &group))
9671            .headers(header_map)
9672            .build()?;
9673        let info = OperationInfo {
9674            operation_id: "core_stats_reset",
9675        };
9676        self.pre(&mut request, &info).await?;
9677        let result = self.exec(request, &info).await;
9678        self.post(&result, &info).await?;
9679        let response = result?;
9680        match response.status().as_u16() {
9681            200u16 => ResponseValue::from_response(response).await,
9682            400u16..=499u16 => Err(Error::ErrorResponse(
9683                ResponseValue::from_response(response).await?,
9684            )),
9685            500u16..=599u16 => Err(Error::ErrorResponse(
9686                ResponseValue::from_response(response).await?,
9687            )),
9688            _ => Err(Error::UnexpectedResponse(response)),
9689        }
9690    }
9691
9692    ///List completed transfers
9693    ///
9694    ///Returns up to 100 recently completed transfers for the requested stats
9695    /// group.
9696    ///
9697    ///Sends a `POST` request to `/core/transferred`
9698    ///
9699    ///Arguments:
9700    /// - `async_`: Run the command asynchronously. Returns a job id
9701    ///   immediately.
9702    /// - `group`: Assign the request to a custom stats group.
9703    /// - `group`: Stats group identifier to filter the completed transfer list.
9704    ///   Leave unset for all groups.
9705    pub async fn core_transferred<'a>(
9706        &'a self,
9707        async_: Option<bool>,
9708        _group: Option<&'a str>,
9709        group: Option<&'a str>
9710    ) -> Result<ResponseValue<types::CoreTransferredResponse>, Error<types::RcError>> {
9711        let url = format!("{}/core/transferred", self.baseurl,);
9712        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9713        header_map.append(
9714            ::reqwest::header::HeaderName::from_static("api-version"),
9715            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9716        );
9717        #[allow(unused_mut)]
9718        let mut request = self
9719            .client
9720            .post(url)
9721            .header(
9722                ::reqwest::header::ACCEPT,
9723                ::reqwest::header::HeaderValue::from_static("application/json"),
9724            )
9725            .query(&progenitor_client::QueryParam::new("_async", &async_))
9726            .query(&progenitor_client::QueryParam::new("_group", &group))
9727            .query(&progenitor_client::QueryParam::new("group", &group))
9728            .headers(header_map)
9729            .build()?;
9730        let info = OperationInfo {
9731            operation_id: "core_transferred",
9732        };
9733        self.pre(&mut request, &info).await?;
9734        let result = self.exec(request, &info).await;
9735        self.post(&result, &info).await?;
9736        let response = result?;
9737        match response.status().as_u16() {
9738            200u16 => ResponseValue::from_response(response).await,
9739            400u16..=499u16 => Err(Error::ErrorResponse(
9740                ResponseValue::from_response(response).await?,
9741            )),
9742            500u16..=599u16 => Err(Error::ErrorResponse(
9743                ResponseValue::from_response(response).await?,
9744            )),
9745            _ => Err(Error::UnexpectedResponse(response)),
9746        }
9747    }
9748
9749    ///Sends a `POST` request to `/debug/set-block-profile-rate`
9750    ///
9751    ///Arguments:
9752    /// - `async_`: Run the command asynchronously. Returns a job id
9753    ///   immediately.
9754    /// - `group`: Assign the request to a custom stats group.
9755    /// - `rate`: Sampling interval in nanoseconds for blocking profile
9756    ///   collection; use 1 to capture all events.
9757    pub async fn debug_set_block_profile_rate<'a>(
9758        &'a self,
9759        async_: Option<bool>,
9760        group: Option<&'a str>,
9761        rate: i64,
9762    ) -> Result<
9763        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9764        Error<types::RcError>,
9765    > {
9766        let url = format!("{}/debug/set-block-profile-rate", self.baseurl,);
9767        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9768        header_map.append(
9769            ::reqwest::header::HeaderName::from_static("api-version"),
9770            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9771        );
9772        #[allow(unused_mut)]
9773        let mut request = self
9774            .client
9775            .post(url)
9776            .header(
9777                ::reqwest::header::ACCEPT,
9778                ::reqwest::header::HeaderValue::from_static("application/json"),
9779            )
9780            .query(&progenitor_client::QueryParam::new("_async", &async_))
9781            .query(&progenitor_client::QueryParam::new("_group", &group))
9782            .query(&progenitor_client::QueryParam::new("rate", &rate))
9783            .headers(header_map)
9784            .build()?;
9785        let info = OperationInfo {
9786            operation_id: "debug_set_block_profile_rate",
9787        };
9788        self.pre(&mut request, &info).await?;
9789        let result = self.exec(request, &info).await;
9790        self.post(&result, &info).await?;
9791        let response = result?;
9792        match response.status().as_u16() {
9793            200u16 => ResponseValue::from_response(response).await,
9794            400u16..=499u16 => Err(Error::ErrorResponse(
9795                ResponseValue::from_response(response).await?,
9796            )),
9797            500u16..=599u16 => Err(Error::ErrorResponse(
9798                ResponseValue::from_response(response).await?,
9799            )),
9800            _ => Err(Error::UnexpectedResponse(response)),
9801        }
9802    }
9803
9804    ///Sends a `POST` request to `/debug/set-gc-percent`
9805    ///
9806    ///Arguments:
9807    /// - `async_`: Run the command asynchronously. Returns a job id
9808    ///   immediately.
9809    /// - `group`: Assign the request to a custom stats group.
9810    /// - `gc_percent`: Target percentage of newly allocated data to trigger
9811    ///   garbage collection.
9812    pub async fn debug_set_gc_percent<'a>(
9813        &'a self,
9814        async_: Option<bool>,
9815        group: Option<&'a str>,
9816        gc_percent: i64,
9817    ) -> Result<ResponseValue<types::DebugSetGcPercentResponse>, Error<types::RcError>> {
9818        let url = format!("{}/debug/set-gc-percent", self.baseurl,);
9819        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9820        header_map.append(
9821            ::reqwest::header::HeaderName::from_static("api-version"),
9822            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9823        );
9824        #[allow(unused_mut)]
9825        let mut request = self
9826            .client
9827            .post(url)
9828            .header(
9829                ::reqwest::header::ACCEPT,
9830                ::reqwest::header::HeaderValue::from_static("application/json"),
9831            )
9832            .query(&progenitor_client::QueryParam::new("_async", &async_))
9833            .query(&progenitor_client::QueryParam::new("_group", &group))
9834            .query(&progenitor_client::QueryParam::new(
9835                "gc-percent",
9836                &gc_percent,
9837            ))
9838            .headers(header_map)
9839            .build()?;
9840        let info = OperationInfo {
9841            operation_id: "debug_set_gc_percent",
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 `/debug/set-mutex-profile-fraction`
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    /// - `rate`: Sampling fraction for mutex contention profiling; set to 0 to
9866    ///   disable.
9867    pub async fn debug_set_mutex_profile_fraction<'a>(
9868        &'a self,
9869        async_: Option<bool>,
9870        group: Option<&'a str>,
9871        rate: i64,
9872    ) -> Result<ResponseValue<types::DebugSetMutexProfileFractionResponse>, Error<types::RcError>>
9873    {
9874        let url = format!("{}/debug/set-mutex-profile-fraction", self.baseurl,);
9875        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9876        header_map.append(
9877            ::reqwest::header::HeaderName::from_static("api-version"),
9878            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9879        );
9880        #[allow(unused_mut)]
9881        let mut request = self
9882            .client
9883            .post(url)
9884            .header(
9885                ::reqwest::header::ACCEPT,
9886                ::reqwest::header::HeaderValue::from_static("application/json"),
9887            )
9888            .query(&progenitor_client::QueryParam::new("_async", &async_))
9889            .query(&progenitor_client::QueryParam::new("_group", &group))
9890            .query(&progenitor_client::QueryParam::new("rate", &rate))
9891            .headers(header_map)
9892            .build()?;
9893        let info = OperationInfo {
9894            operation_id: "debug_set_mutex_profile_fraction",
9895        };
9896        self.pre(&mut request, &info).await?;
9897        let result = self.exec(request, &info).await;
9898        self.post(&result, &info).await?;
9899        let response = result?;
9900        match response.status().as_u16() {
9901            200u16 => ResponseValue::from_response(response).await,
9902            400u16..=499u16 => Err(Error::ErrorResponse(
9903                ResponseValue::from_response(response).await?,
9904            )),
9905            500u16..=599u16 => Err(Error::ErrorResponse(
9906                ResponseValue::from_response(response).await?,
9907            )),
9908            _ => Err(Error::UnexpectedResponse(response)),
9909        }
9910    }
9911
9912    ///Sends a `POST` request to `/debug/set-soft-memory-limit`
9913    ///
9914    ///Arguments:
9915    /// - `async_`: Run the command asynchronously. Returns a job id
9916    ///   immediately.
9917    /// - `group`: Assign the request to a custom stats group.
9918    /// - `mem_limit`: Soft memory limit for the Go runtime in bytes.
9919    pub async fn debug_set_soft_memory_limit<'a>(
9920        &'a self,
9921        async_: Option<bool>,
9922        group: Option<&'a str>,
9923        mem_limit: i64,
9924    ) -> Result<ResponseValue<types::DebugSetSoftMemoryLimitResponse>, Error<types::RcError>> {
9925        let url = format!("{}/debug/set-soft-memory-limit", self.baseurl,);
9926        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9927        header_map.append(
9928            ::reqwest::header::HeaderName::from_static("api-version"),
9929            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9930        );
9931        #[allow(unused_mut)]
9932        let mut request = self
9933            .client
9934            .post(url)
9935            .header(
9936                ::reqwest::header::ACCEPT,
9937                ::reqwest::header::HeaderValue::from_static("application/json"),
9938            )
9939            .query(&progenitor_client::QueryParam::new("_async", &async_))
9940            .query(&progenitor_client::QueryParam::new("_group", &group))
9941            .query(&progenitor_client::QueryParam::new("mem-limit", &mem_limit))
9942            .headers(header_map)
9943            .build()?;
9944        let info = OperationInfo {
9945            operation_id: "debug_set_soft_memory_limit",
9946        };
9947        self.pre(&mut request, &info).await?;
9948        let result = self.exec(request, &info).await;
9949        self.post(&result, &info).await?;
9950        let response = result?;
9951        match response.status().as_u16() {
9952            200u16 => ResponseValue::from_response(response).await,
9953            400u16..=499u16 => Err(Error::ErrorResponse(
9954                ResponseValue::from_response(response).await?,
9955            )),
9956            500u16..=599u16 => Err(Error::ErrorResponse(
9957                ResponseValue::from_response(response).await?,
9958            )),
9959            _ => Err(Error::UnexpectedResponse(response)),
9960        }
9961    }
9962
9963    ///Sends a `POST` request to `/fscache/clear`
9964    ///
9965    ///Arguments:
9966    /// - `async_`: Run the command asynchronously. Returns a job id
9967    ///   immediately.
9968    /// - `group`: Assign the request to a custom stats group.
9969    pub async fn fscache_clear<'a>(
9970        &'a self,
9971        async_: Option<bool>,
9972        group: Option<&'a str>,
9973    ) -> Result<
9974        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9975        Error<types::RcError>,
9976    > {
9977        let url = format!("{}/fscache/clear", self.baseurl,);
9978        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9979        header_map.append(
9980            ::reqwest::header::HeaderName::from_static("api-version"),
9981            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9982        );
9983        #[allow(unused_mut)]
9984        let mut request = self
9985            .client
9986            .post(url)
9987            .header(
9988                ::reqwest::header::ACCEPT,
9989                ::reqwest::header::HeaderValue::from_static("application/json"),
9990            )
9991            .query(&progenitor_client::QueryParam::new("_async", &async_))
9992            .query(&progenitor_client::QueryParam::new("_group", &group))
9993            .headers(header_map)
9994            .build()?;
9995        let info = OperationInfo {
9996            operation_id: "fscache_clear",
9997        };
9998        self.pre(&mut request, &info).await?;
9999        let result = self.exec(request, &info).await;
10000        self.post(&result, &info).await?;
10001        let response = result?;
10002        match response.status().as_u16() {
10003            200u16 => ResponseValue::from_response(response).await,
10004            400u16..=499u16 => Err(Error::ErrorResponse(
10005                ResponseValue::from_response(response).await?,
10006            )),
10007            500u16..=599u16 => Err(Error::ErrorResponse(
10008                ResponseValue::from_response(response).await?,
10009            )),
10010            _ => Err(Error::UnexpectedResponse(response)),
10011        }
10012    }
10013
10014    ///Sends a `POST` request to `/fscache/entries`
10015    ///
10016    ///Arguments:
10017    /// - `async_`: Run the command asynchronously. Returns a job id
10018    ///   immediately.
10019    /// - `group`: Assign the request to a custom stats group.
10020    pub async fn fscache_entries<'a>(
10021        &'a self,
10022        async_: Option<bool>,
10023        group: Option<&'a str>,
10024    ) -> Result<ResponseValue<types::FscacheEntriesResponse>, Error<types::RcError>> {
10025        let url = format!("{}/fscache/entries", self.baseurl,);
10026        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10027        header_map.append(
10028            ::reqwest::header::HeaderName::from_static("api-version"),
10029            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10030        );
10031        #[allow(unused_mut)]
10032        let mut request = self
10033            .client
10034            .post(url)
10035            .header(
10036                ::reqwest::header::ACCEPT,
10037                ::reqwest::header::HeaderValue::from_static("application/json"),
10038            )
10039            .query(&progenitor_client::QueryParam::new("_async", &async_))
10040            .query(&progenitor_client::QueryParam::new("_group", &group))
10041            .headers(header_map)
10042            .build()?;
10043        let info = OperationInfo {
10044            operation_id: "fscache_entries",
10045        };
10046        self.pre(&mut request, &info).await?;
10047        let result = self.exec(request, &info).await;
10048        self.post(&result, &info).await?;
10049        let response = result?;
10050        match response.status().as_u16() {
10051            200u16 => ResponseValue::from_response(response).await,
10052            400u16..=499u16 => Err(Error::ErrorResponse(
10053                ResponseValue::from_response(response).await?,
10054            )),
10055            500u16..=599u16 => Err(Error::ErrorResponse(
10056                ResponseValue::from_response(response).await?,
10057            )),
10058            _ => Err(Error::UnexpectedResponse(response)),
10059        }
10060    }
10061
10062    ///Sends a `POST` request to `/mount/listmounts`
10063    ///
10064    ///Arguments:
10065    /// - `async_`: Run the command asynchronously. Returns a job id
10066    ///   immediately.
10067    /// - `group`: Assign the request to a custom stats group.
10068    pub async fn mount_listmounts<'a>(
10069        &'a self,
10070        async_: Option<bool>,
10071        group: Option<&'a str>,
10072    ) -> Result<ResponseValue<types::MountListmountsResponse>, Error<types::RcError>> {
10073        let url = format!("{}/mount/listmounts", self.baseurl,);
10074        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10075        header_map.append(
10076            ::reqwest::header::HeaderName::from_static("api-version"),
10077            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10078        );
10079        #[allow(unused_mut)]
10080        let mut request = self
10081            .client
10082            .post(url)
10083            .header(
10084                ::reqwest::header::ACCEPT,
10085                ::reqwest::header::HeaderValue::from_static("application/json"),
10086            )
10087            .query(&progenitor_client::QueryParam::new("_async", &async_))
10088            .query(&progenitor_client::QueryParam::new("_group", &group))
10089            .headers(header_map)
10090            .build()?;
10091        let info = OperationInfo {
10092            operation_id: "mount_listmounts",
10093        };
10094        self.pre(&mut request, &info).await?;
10095        let result = self.exec(request, &info).await;
10096        self.post(&result, &info).await?;
10097        let response = result?;
10098        match response.status().as_u16() {
10099            200u16 => ResponseValue::from_response(response).await,
10100            400u16..=499u16 => Err(Error::ErrorResponse(
10101                ResponseValue::from_response(response).await?,
10102            )),
10103            500u16..=599u16 => Err(Error::ErrorResponse(
10104                ResponseValue::from_response(response).await?,
10105            )),
10106            _ => Err(Error::UnexpectedResponse(response)),
10107        }
10108    }
10109
10110    ///Sends a `POST` request to `/mount/mount`
10111    ///
10112    ///Arguments:
10113    /// - `async_`: Run the command asynchronously. Returns a job id
10114    ///   immediately.
10115    /// - `config`: JSON encoded config overrides applied for this call only.
10116    /// - `filter`: JSON encoded filter overrides applied for this call only.
10117    /// - `group`: Assign the request to a custom stats group.
10118    /// - `fs`: Remote path to mount, such as `drive:` or `remote:subdir`.
10119    /// - `mount_opt`: Mount options encoded as JSON, matching flags accepted by
10120    ///   `rclone mount`.
10121    /// - `mount_point`: Absolute local path where the remote should be mounted.
10122    /// - `mount_type`: Optional mount implementation to use (`mount`, `cmount`,
10123    ///   or `mount2`).
10124    /// - `vfs_opt`: VFS options encoded as JSON, matching flags accepted by
10125    ///   `rclone mount`.
10126    pub async fn mount_mount<'a>(
10127        &'a self,
10128        async_: Option<bool>,
10129        config: Option<&'a str>,
10130        filter: Option<&'a str>,
10131        group: Option<&'a str>,
10132        fs: &'a str,
10133        mount_opt: Option<&'a str>,
10134        mount_point: &'a str,
10135        mount_type: Option<&'a str>,
10136        vfs_opt: Option<&'a str>,
10137    ) -> Result<
10138        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10139        Error<types::RcError>,
10140    > {
10141        let url = format!("{}/mount/mount", self.baseurl,);
10142        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10143        header_map.append(
10144            ::reqwest::header::HeaderName::from_static("api-version"),
10145            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10146        );
10147        #[allow(unused_mut)]
10148        let mut request = self
10149            .client
10150            .post(url)
10151            .header(
10152                ::reqwest::header::ACCEPT,
10153                ::reqwest::header::HeaderValue::from_static("application/json"),
10154            )
10155            .query(&progenitor_client::QueryParam::new("_async", &async_))
10156            .query(&progenitor_client::QueryParam::new("_config", &config))
10157            .query(&progenitor_client::QueryParam::new("_filter", &filter))
10158            .query(&progenitor_client::QueryParam::new("_group", &group))
10159            .query(&progenitor_client::QueryParam::new("fs", &fs))
10160            .query(&progenitor_client::QueryParam::new("mountOpt", &mount_opt))
10161            .query(&progenitor_client::QueryParam::new(
10162                "mountPoint",
10163                &mount_point,
10164            ))
10165            .query(&progenitor_client::QueryParam::new(
10166                "mountType",
10167                &mount_type,
10168            ))
10169            .query(&progenitor_client::QueryParam::new("vfsOpt", &vfs_opt))
10170            .headers(header_map)
10171            .build()?;
10172        let info = OperationInfo {
10173            operation_id: "mount_mount",
10174        };
10175        self.pre(&mut request, &info).await?;
10176        let result = self.exec(request, &info).await;
10177        self.post(&result, &info).await?;
10178        let response = result?;
10179        match response.status().as_u16() {
10180            200u16 => ResponseValue::from_response(response).await,
10181            400u16..=499u16 => Err(Error::ErrorResponse(
10182                ResponseValue::from_response(response).await?,
10183            )),
10184            500u16..=599u16 => Err(Error::ErrorResponse(
10185                ResponseValue::from_response(response).await?,
10186            )),
10187            _ => Err(Error::UnexpectedResponse(response)),
10188        }
10189    }
10190
10191    ///Sends a `POST` request to `/mount/types`
10192    ///
10193    ///Arguments:
10194    /// - `async_`: Run the command asynchronously. Returns a job id
10195    ///   immediately.
10196    /// - `group`: Assign the request to a custom stats group.
10197    pub async fn mount_types<'a>(
10198        &'a self,
10199        async_: Option<bool>,
10200        group: Option<&'a str>,
10201    ) -> Result<ResponseValue<types::MountTypesResponse>, Error<types::RcError>> {
10202        let url = format!("{}/mount/types", self.baseurl,);
10203        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10204        header_map.append(
10205            ::reqwest::header::HeaderName::from_static("api-version"),
10206            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10207        );
10208        #[allow(unused_mut)]
10209        let mut request = self
10210            .client
10211            .post(url)
10212            .header(
10213                ::reqwest::header::ACCEPT,
10214                ::reqwest::header::HeaderValue::from_static("application/json"),
10215            )
10216            .query(&progenitor_client::QueryParam::new("_async", &async_))
10217            .query(&progenitor_client::QueryParam::new("_group", &group))
10218            .headers(header_map)
10219            .build()?;
10220        let info = OperationInfo {
10221            operation_id: "mount_types",
10222        };
10223        self.pre(&mut request, &info).await?;
10224        let result = self.exec(request, &info).await;
10225        self.post(&result, &info).await?;
10226        let response = result?;
10227        match response.status().as_u16() {
10228            200u16 => ResponseValue::from_response(response).await,
10229            400u16..=499u16 => Err(Error::ErrorResponse(
10230                ResponseValue::from_response(response).await?,
10231            )),
10232            500u16..=599u16 => Err(Error::ErrorResponse(
10233                ResponseValue::from_response(response).await?,
10234            )),
10235            _ => Err(Error::UnexpectedResponse(response)),
10236        }
10237    }
10238
10239    ///Sends a `POST` request to `/mount/unmount`
10240    ///
10241    ///Arguments:
10242    /// - `async_`: Run the command asynchronously. Returns a job id
10243    ///   immediately.
10244    /// - `group`: Assign the request to a custom stats group.
10245    /// - `mount_point`: Local mount point path to unmount.
10246    pub async fn mount_unmount<'a>(
10247        &'a self,
10248        async_: Option<bool>,
10249        group: Option<&'a str>,
10250        mount_point: &'a str,
10251    ) -> Result<
10252        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10253        Error<types::RcError>,
10254    > {
10255        let url = format!("{}/mount/unmount", self.baseurl,);
10256        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10257        header_map.append(
10258            ::reqwest::header::HeaderName::from_static("api-version"),
10259            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10260        );
10261        #[allow(unused_mut)]
10262        let mut request = self
10263            .client
10264            .post(url)
10265            .header(
10266                ::reqwest::header::ACCEPT,
10267                ::reqwest::header::HeaderValue::from_static("application/json"),
10268            )
10269            .query(&progenitor_client::QueryParam::new("_async", &async_))
10270            .query(&progenitor_client::QueryParam::new("_group", &group))
10271            .query(&progenitor_client::QueryParam::new(
10272                "mountPoint",
10273                &mount_point,
10274            ))
10275            .headers(header_map)
10276            .build()?;
10277        let info = OperationInfo {
10278            operation_id: "mount_unmount",
10279        };
10280        self.pre(&mut request, &info).await?;
10281        let result = self.exec(request, &info).await;
10282        self.post(&result, &info).await?;
10283        let response = result?;
10284        match response.status().as_u16() {
10285            200u16 => ResponseValue::from_response(response).await,
10286            400u16..=499u16 => Err(Error::ErrorResponse(
10287                ResponseValue::from_response(response).await?,
10288            )),
10289            500u16..=599u16 => Err(Error::ErrorResponse(
10290                ResponseValue::from_response(response).await?,
10291            )),
10292            _ => Err(Error::UnexpectedResponse(response)),
10293        }
10294    }
10295
10296    ///Sends a `POST` request to `/mount/unmountall`
10297    ///
10298    ///Arguments:
10299    /// - `async_`: Run the command asynchronously. Returns a job id
10300    ///   immediately.
10301    /// - `group`: Assign the request to a custom stats group.
10302    pub async fn mount_unmountall<'a>(
10303        &'a self,
10304        async_: Option<bool>,
10305        group: Option<&'a str>,
10306    ) -> Result<
10307        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10308        Error<types::RcError>,
10309    > {
10310        let url = format!("{}/mount/unmountall", self.baseurl,);
10311        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10312        header_map.append(
10313            ::reqwest::header::HeaderName::from_static("api-version"),
10314            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10315        );
10316        #[allow(unused_mut)]
10317        let mut request = self
10318            .client
10319            .post(url)
10320            .header(
10321                ::reqwest::header::ACCEPT,
10322                ::reqwest::header::HeaderValue::from_static("application/json"),
10323            )
10324            .query(&progenitor_client::QueryParam::new("_async", &async_))
10325            .query(&progenitor_client::QueryParam::new("_group", &group))
10326            .headers(header_map)
10327            .build()?;
10328        let info = OperationInfo {
10329            operation_id: "mount_unmountall",
10330        };
10331        self.pre(&mut request, &info).await?;
10332        let result = self.exec(request, &info).await;
10333        self.post(&result, &info).await?;
10334        let response = result?;
10335        match response.status().as_u16() {
10336            200u16 => ResponseValue::from_response(response).await,
10337            400u16..=499u16 => Err(Error::ErrorResponse(
10338                ResponseValue::from_response(response).await?,
10339            )),
10340            500u16..=599u16 => Err(Error::ErrorResponse(
10341                ResponseValue::from_response(response).await?,
10342            )),
10343            _ => Err(Error::UnexpectedResponse(response)),
10344        }
10345    }
10346
10347    ///Echo parameters (auth required)
10348    ///
10349    ///Same as `rc/noop`, but requires authentication to validate access
10350    /// control.
10351    ///
10352    ///Sends a `POST` request to `/rc/noopauth`
10353    ///
10354    ///Arguments:
10355    /// - `async_`: Run the command asynchronously. Returns a job id
10356    ///   immediately.
10357    /// - `params`: Additional arbitrary parameters allowed.
10358    pub async fn rc_noop_auth<'a>(
10359        &'a self,
10360        async_: Option<bool>,
10361        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10362    ) -> Result<
10363        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10364        Error<types::RcError>,
10365    > {
10366        let url = format!("{}/rc/noopauth", self.baseurl,);
10367        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10368        header_map.append(
10369            ::reqwest::header::HeaderName::from_static("api-version"),
10370            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10371        );
10372        #[allow(unused_mut)]
10373        let mut request = self
10374            .client
10375            .post(url)
10376            .header(
10377                ::reqwest::header::ACCEPT,
10378                ::reqwest::header::HeaderValue::from_static("application/json"),
10379            )
10380            .query(&progenitor_client::QueryParam::new("_async", &async_))
10381            .query(&progenitor_client::QueryParam::new("params", &params))
10382            .headers(header_map)
10383            .build()?;
10384        let info = OperationInfo {
10385            operation_id: "rc_noop_auth",
10386        };
10387        self.pre(&mut request, &info).await?;
10388        let result = self.exec(request, &info).await;
10389        self.post(&result, &info).await?;
10390        let response = result?;
10391        match response.status().as_u16() {
10392            200u16 => ResponseValue::from_response(response).await,
10393            400u16..=499u16 => Err(Error::ErrorResponse(
10394                ResponseValue::from_response(response).await?,
10395            )),
10396            500u16..=599u16 => Err(Error::ErrorResponse(
10397                ResponseValue::from_response(response).await?,
10398            )),
10399            _ => Err(Error::UnexpectedResponse(response)),
10400        }
10401    }
10402
10403    ///Return a test error
10404    ///
10405    ///Always returns an error response incorporating the supplied parameters,
10406    /// useful for testing error handling.
10407    ///
10408    ///Sends a `POST` request to `/rc/error`
10409    ///
10410    ///Arguments:
10411    /// - `async_`: Run the command asynchronously. Returns a job id
10412    ///   immediately.
10413    /// - `params`: Additional arbitrary parameters allowed.
10414    pub async fn rc_error<'a>(
10415        &'a self,
10416        async_: Option<bool>,
10417        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10418    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10419        let url = format!("{}/rc/error", self.baseurl,);
10420        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10421        header_map.append(
10422            ::reqwest::header::HeaderName::from_static("api-version"),
10423            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10424        );
10425        #[allow(unused_mut)]
10426        let mut request = self
10427            .client
10428            .post(url)
10429            .header(
10430                ::reqwest::header::ACCEPT,
10431                ::reqwest::header::HeaderValue::from_static("application/json"),
10432            )
10433            .query(&progenitor_client::QueryParam::new("_async", &async_))
10434            .query(&progenitor_client::QueryParam::new("params", &params))
10435            .headers(header_map)
10436            .build()?;
10437        let info = OperationInfo {
10438            operation_id: "rc_error",
10439        };
10440        self.pre(&mut request, &info).await?;
10441        let result = self.exec(request, &info).await;
10442        self.post(&result, &info).await?;
10443        let response = result?;
10444        match response.status().as_u16() {
10445            200u16 => Ok(ResponseValue::empty(response)),
10446            400u16..=499u16 => Err(Error::ErrorResponse(
10447                ResponseValue::from_response(response).await?,
10448            )),
10449            500u16..=599u16 => Err(Error::ErrorResponse(
10450                ResponseValue::from_response(response).await?,
10451            )),
10452            _ => Err(Error::UnexpectedResponse(response)),
10453        }
10454    }
10455
10456    ///List RC commands
10457    ///
10458    ///Returns metadata about every available RC command, including whether
10459    /// authentication is required.
10460    ///
10461    ///Sends a `POST` request to `/rc/list`
10462    ///
10463    ///Arguments:
10464    /// - `async_`: Run the command asynchronously. Returns a job id
10465    ///   immediately.
10466    /// - `group`: Assign the request to a custom stats group.
10467    pub async fn rc_list<'a>(
10468        &'a self,
10469        async_: Option<bool>,
10470        group: Option<&'a str>,
10471    ) -> Result<ResponseValue<types::RcListResponse>, Error<types::RcError>> {
10472        let url = format!("{}/rc/list", self.baseurl,);
10473        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10474        header_map.append(
10475            ::reqwest::header::HeaderName::from_static("api-version"),
10476            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10477        );
10478        #[allow(unused_mut)]
10479        let mut request = self
10480            .client
10481            .post(url)
10482            .header(
10483                ::reqwest::header::ACCEPT,
10484                ::reqwest::header::HeaderValue::from_static("application/json"),
10485            )
10486            .query(&progenitor_client::QueryParam::new("_async", &async_))
10487            .query(&progenitor_client::QueryParam::new("_group", &group))
10488            .headers(header_map)
10489            .build()?;
10490        let info = OperationInfo {
10491            operation_id: "rc_list",
10492        };
10493        self.pre(&mut request, &info).await?;
10494        let result = self.exec(request, &info).await;
10495        self.post(&result, &info).await?;
10496        let response = result?;
10497        match response.status().as_u16() {
10498            200u16 => ResponseValue::from_response(response).await,
10499            400u16..=499u16 => Err(Error::ErrorResponse(
10500                ResponseValue::from_response(response).await?,
10501            )),
10502            500u16..=599u16 => Err(Error::ErrorResponse(
10503                ResponseValue::from_response(response).await?,
10504            )),
10505            _ => Err(Error::UnexpectedResponse(response)),
10506        }
10507    }
10508
10509    ///Run backend command
10510    ///
10511    ///Invokes a backend-specific management command against an optional
10512    /// remote.
10513    ///
10514    ///Sends a `POST` request to `/backend/command`
10515    ///
10516    ///Arguments:
10517    /// - `async_`: Run the command asynchronously. Returns a job id
10518    ///   immediately.
10519    /// - `group`: Assign the request to a custom stats group.
10520    /// - `arg`: Optional positional arguments for the backend command.
10521    /// - `command`: Backend-specific command to invoke.
10522    /// - `fs`: Remote name or path the backend command should target.
10523    /// - `opt`: Backend command options encoded as a JSON string.
10524    pub async fn backend_command<'a>(
10525        &'a self,
10526        async_: Option<bool>,
10527        group: Option<&'a str>,
10528        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
10529        command: &'a str,
10530        fs: Option<&'a str>,
10531        opt: Option<&'a str>,
10532    ) -> Result<ResponseValue<types::BackendCommandResponse>, Error<types::RcError>> {
10533        let url = format!("{}/backend/command", self.baseurl,);
10534        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10535        header_map.append(
10536            ::reqwest::header::HeaderName::from_static("api-version"),
10537            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10538        );
10539        #[allow(unused_mut)]
10540        let mut request = self
10541            .client
10542            .post(url)
10543            .header(
10544                ::reqwest::header::ACCEPT,
10545                ::reqwest::header::HeaderValue::from_static("application/json"),
10546            )
10547            .query(&progenitor_client::QueryParam::new("_async", &async_))
10548            .query(&progenitor_client::QueryParam::new("_group", &group))
10549            .query(&progenitor_client::QueryParam::new("arg", &arg))
10550            .query(&progenitor_client::QueryParam::new("command", &command))
10551            .query(&progenitor_client::QueryParam::new("fs", &fs))
10552            .query(&progenitor_client::QueryParam::new("opt", &opt))
10553            .headers(header_map)
10554            .build()?;
10555        let info = OperationInfo {
10556            operation_id: "backend_command",
10557        };
10558        self.pre(&mut request, &info).await?;
10559        let result = self.exec(request, &info).await;
10560        self.post(&result, &info).await?;
10561        let response = result?;
10562        match response.status().as_u16() {
10563            200u16 => ResponseValue::from_response(response).await,
10564            400u16..=499u16 => Err(Error::ErrorResponse(
10565                ResponseValue::from_response(response).await?,
10566            )),
10567            500u16..=599u16 => Err(Error::ErrorResponse(
10568                ResponseValue::from_response(response).await?,
10569            )),
10570            _ => Err(Error::UnexpectedResponse(response)),
10571        }
10572    }
10573
10574    ///Expire cache entries
10575    ///
10576    ///Drops cached directory entries, and optionally cached file data, for the
10577    /// cache backend.
10578    ///
10579    ///Sends a `POST` request to `/cache/expire`
10580    ///
10581    ///Arguments:
10582    /// - `async_`: Run the command asynchronously. Returns a job id
10583    ///   immediately.
10584    /// - `group`: Assign the request to a custom stats group.
10585    /// - `remote`: Remote path to expire from the cache, e.g.
10586    ///   `remote:path/to/dir`.
10587    /// - `with_data`: Set to true to drop cached chunk data along with
10588    ///   directory entries.
10589    pub async fn cache_expire<'a>(
10590        &'a self,
10591        async_: Option<bool>,
10592        group: Option<&'a str>,
10593        remote: &'a str,
10594        with_data: Option<bool>,
10595    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10596        let url = format!("{}/cache/expire", self.baseurl,);
10597        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10598        header_map.append(
10599            ::reqwest::header::HeaderName::from_static("api-version"),
10600            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10601        );
10602        #[allow(unused_mut)]
10603        let mut request = self
10604            .client
10605            .post(url)
10606            .header(
10607                ::reqwest::header::ACCEPT,
10608                ::reqwest::header::HeaderValue::from_static("application/json"),
10609            )
10610            .query(&progenitor_client::QueryParam::new("_async", &async_))
10611            .query(&progenitor_client::QueryParam::new("_group", &group))
10612            .query(&progenitor_client::QueryParam::new("remote", &remote))
10613            .query(&progenitor_client::QueryParam::new("withData", &with_data))
10614            .headers(header_map)
10615            .build()?;
10616        let info = OperationInfo {
10617            operation_id: "cache_expire",
10618        };
10619        self.pre(&mut request, &info).await?;
10620        let result = self.exec(request, &info).await;
10621        self.post(&result, &info).await?;
10622        let response = result?;
10623        match response.status().as_u16() {
10624            200u16 => Ok(ResponseValue::empty(response)),
10625            400u16..=499u16 => Err(Error::ErrorResponse(
10626                ResponseValue::from_response(response).await?,
10627            )),
10628            500u16..=599u16 => Err(Error::ErrorResponse(
10629                ResponseValue::from_response(response).await?,
10630            )),
10631            _ => Err(Error::UnexpectedResponse(response)),
10632        }
10633    }
10634
10635    ///Prefetch cache chunks
10636    ///
10637    ///Ensures specified file chunks are cached locally for a cache remote.
10638    ///
10639    ///Sends a `POST` request to `/cache/fetch`
10640    ///
10641    ///Arguments:
10642    /// - `async_`: Run the command asynchronously. Returns a job id
10643    ///   immediately.
10644    /// - `group`: Assign the request to a custom stats group.
10645    /// - `chunks`: Comma-separated chunk specifier list (e.g. `0:10,25:30`)
10646    ///   describing file pieces to prefetch.
10647    /// - `params`: Additional arbitrary parameters allowed.
10648    pub async fn cache_fetch<'a>(
10649        &'a self,
10650        async_: Option<bool>,
10651        group: Option<&'a str>,
10652        chunks: Option<&'a str>,
10653        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10654    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10655        let url = format!("{}/cache/fetch", self.baseurl,);
10656        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10657        header_map.append(
10658            ::reqwest::header::HeaderName::from_static("api-version"),
10659            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10660        );
10661        #[allow(unused_mut)]
10662        let mut request = self
10663            .client
10664            .post(url)
10665            .header(
10666                ::reqwest::header::ACCEPT,
10667                ::reqwest::header::HeaderValue::from_static("application/json"),
10668            )
10669            .query(&progenitor_client::QueryParam::new("_async", &async_))
10670            .query(&progenitor_client::QueryParam::new("_group", &group))
10671            .query(&progenitor_client::QueryParam::new("chunks", &chunks))
10672            .query(&progenitor_client::QueryParam::new("params", &params))
10673            .headers(header_map)
10674            .build()?;
10675        let info = OperationInfo {
10676            operation_id: "cache_fetch",
10677        };
10678        self.pre(&mut request, &info).await?;
10679        let result = self.exec(request, &info).await;
10680        self.post(&result, &info).await?;
10681        let response = result?;
10682        match response.status().as_u16() {
10683            200u16 => Ok(ResponseValue::empty(response)),
10684            400u16..=499u16 => Err(Error::ErrorResponse(
10685                ResponseValue::from_response(response).await?,
10686            )),
10687            500u16..=599u16 => Err(Error::ErrorResponse(
10688                ResponseValue::from_response(response).await?,
10689            )),
10690            _ => Err(Error::UnexpectedResponse(response)),
10691        }
10692    }
10693
10694    ///Show cache stats
10695    ///
10696    ///Returns runtime statistics for the cache backend.
10697    ///
10698    ///Sends a `POST` request to `/cache/stats`
10699    ///
10700    ///Arguments:
10701    /// - `async_`: Run the command asynchronously. Returns a job id
10702    ///   immediately.
10703    /// - `group`: Assign the request to a custom stats group.
10704    pub async fn cache_stats<'a>(
10705        &'a self,
10706        async_: Option<bool>,
10707        group: Option<&'a str>,
10708    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10709        let url = format!("{}/cache/stats", self.baseurl,);
10710        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10711        header_map.append(
10712            ::reqwest::header::HeaderName::from_static("api-version"),
10713            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10714        );
10715        #[allow(unused_mut)]
10716        let mut request = self
10717            .client
10718            .post(url)
10719            .header(
10720                ::reqwest::header::ACCEPT,
10721                ::reqwest::header::HeaderValue::from_static("application/json"),
10722            )
10723            .query(&progenitor_client::QueryParam::new("_async", &async_))
10724            .query(&progenitor_client::QueryParam::new("_group", &group))
10725            .headers(header_map)
10726            .build()?;
10727        let info = OperationInfo {
10728            operation_id: "cache_stats",
10729        };
10730        self.pre(&mut request, &info).await?;
10731        let result = self.exec(request, &info).await;
10732        self.post(&result, &info).await?;
10733        let response = result?;
10734        match response.status().as_u16() {
10735            200u16 => Ok(ResponseValue::empty(response)),
10736            400u16..=499u16 => Err(Error::ErrorResponse(
10737                ResponseValue::from_response(response).await?,
10738            )),
10739            500u16..=599u16 => Err(Error::ErrorResponse(
10740                ResponseValue::from_response(response).await?,
10741            )),
10742            _ => Err(Error::UnexpectedResponse(response)),
10743        }
10744    }
10745
10746    ///Create remote configuration
10747    ///
10748    ///Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
10749    ///
10750    ///Sends a `POST` request to `/config/create`
10751    ///
10752    ///Arguments:
10753    /// - `async_`: Run the command asynchronously. Returns a job id
10754    ///   immediately.
10755    /// - `group`: Assign the request to a custom stats group.
10756    /// - `name`: Name of the new remote configuration.
10757    /// - `opt`: Optional JSON object controlling interactive behaviour (e.g.
10758    ///   `obscure`, `continue`).
10759    /// - `parameters`: JSON object of configuration key/value pairs required
10760    ///   for the remote.
10761    /// - `type_`: Backend type identifier, such as `drive`, `s3`, or `dropbox`.
10762    pub async fn config_create<'a>(
10763        &'a self,
10764        async_: Option<bool>,
10765        group: Option<&'a str>,
10766        name: &'a str,
10767        opt: Option<&'a str>,
10768        parameters: &'a str,
10769        type_: &'a str,
10770    ) -> Result<
10771        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10772        Error<types::RcError>,
10773    > {
10774        let url = format!("{}/config/create", self.baseurl,);
10775        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10776        header_map.append(
10777            ::reqwest::header::HeaderName::from_static("api-version"),
10778            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10779        );
10780        #[allow(unused_mut)]
10781        let mut request = self
10782            .client
10783            .post(url)
10784            .header(
10785                ::reqwest::header::ACCEPT,
10786                ::reqwest::header::HeaderValue::from_static("application/json"),
10787            )
10788            .query(&progenitor_client::QueryParam::new("_async", &async_))
10789            .query(&progenitor_client::QueryParam::new("_group", &group))
10790            .query(&progenitor_client::QueryParam::new("name", &name))
10791            .query(&progenitor_client::QueryParam::new("opt", &opt))
10792            .query(&progenitor_client::QueryParam::new(
10793                "parameters",
10794                &parameters,
10795            ))
10796            .query(&progenitor_client::QueryParam::new("type", &type_))
10797            .headers(header_map)
10798            .build()?;
10799        let info = OperationInfo {
10800            operation_id: "config_create",
10801        };
10802        self.pre(&mut request, &info).await?;
10803        let result = self.exec(request, &info).await;
10804        self.post(&result, &info).await?;
10805        let response = result?;
10806        match response.status().as_u16() {
10807            200u16 => ResponseValue::from_response(response).await,
10808            400u16..=499u16 => Err(Error::ErrorResponse(
10809                ResponseValue::from_response(response).await?,
10810            )),
10811            500u16..=599u16 => Err(Error::ErrorResponse(
10812                ResponseValue::from_response(response).await?,
10813            )),
10814            _ => Err(Error::UnexpectedResponse(response)),
10815        }
10816    }
10817
10818    ///Delete remote configuration
10819    ///
10820    ///Removes an existing remote from `rclone.conf`.
10821    ///
10822    ///Sends a `POST` request to `/config/delete`
10823    ///
10824    ///Arguments:
10825    /// - `async_`: Run the command asynchronously. Returns a job id
10826    ///   immediately.
10827    /// - `group`: Assign the request to a custom stats group.
10828    /// - `name`: Name of the remote configuration to delete.
10829    pub async fn config_delete<'a>(
10830        &'a self,
10831        async_: Option<bool>,
10832        group: Option<&'a str>,
10833        name: &'a str,
10834    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10835        let url = format!("{}/config/delete", self.baseurl,);
10836        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10837        header_map.append(
10838            ::reqwest::header::HeaderName::from_static("api-version"),
10839            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10840        );
10841        #[allow(unused_mut)]
10842        let mut request = self
10843            .client
10844            .post(url)
10845            .header(
10846                ::reqwest::header::ACCEPT,
10847                ::reqwest::header::HeaderValue::from_static("application/json"),
10848            )
10849            .query(&progenitor_client::QueryParam::new("_async", &async_))
10850            .query(&progenitor_client::QueryParam::new("_group", &group))
10851            .query(&progenitor_client::QueryParam::new("name", &name))
10852            .headers(header_map)
10853            .build()?;
10854        let info = OperationInfo {
10855            operation_id: "config_delete",
10856        };
10857        self.pre(&mut request, &info).await?;
10858        let result = self.exec(request, &info).await;
10859        self.post(&result, &info).await?;
10860        let response = result?;
10861        match response.status().as_u16() {
10862            200u16 => Ok(ResponseValue::empty(response)),
10863            400u16..=499u16 => Err(Error::ErrorResponse(
10864                ResponseValue::from_response(response).await?,
10865            )),
10866            500u16..=599u16 => Err(Error::ErrorResponse(
10867                ResponseValue::from_response(response).await?,
10868            )),
10869            _ => Err(Error::UnexpectedResponse(response)),
10870        }
10871    }
10872
10873    ///Dump configuration
10874    ///
10875    ///Returns the contents of the config file as a JSON object keyed by remote
10876    /// name.
10877    ///
10878    ///Sends a `POST` request to `/config/dump`
10879    ///
10880    ///Arguments:
10881    /// - `async_`: Run the command asynchronously. Returns a job id
10882    ///   immediately.
10883    /// - `group`: Assign the request to a custom stats group.
10884    pub async fn config_dump<'a>(
10885        &'a self,
10886        async_: Option<bool>,
10887        group: Option<&'a str>,
10888    ) -> Result<
10889        ResponseValue<
10890            ::std::collections::HashMap<
10891                ::std::string::String,
10892                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
10893            >,
10894        >,
10895        Error<types::RcError>,
10896    > {
10897        let url = format!("{}/config/dump", self.baseurl,);
10898        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10899        header_map.append(
10900            ::reqwest::header::HeaderName::from_static("api-version"),
10901            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10902        );
10903        #[allow(unused_mut)]
10904        let mut request = self
10905            .client
10906            .post(url)
10907            .header(
10908                ::reqwest::header::ACCEPT,
10909                ::reqwest::header::HeaderValue::from_static("application/json"),
10910            )
10911            .query(&progenitor_client::QueryParam::new("_async", &async_))
10912            .query(&progenitor_client::QueryParam::new("_group", &group))
10913            .headers(header_map)
10914            .build()?;
10915        let info = OperationInfo {
10916            operation_id: "config_dump",
10917        };
10918        self.pre(&mut request, &info).await?;
10919        let result = self.exec(request, &info).await;
10920        self.post(&result, &info).await?;
10921        let response = result?;
10922        match response.status().as_u16() {
10923            200u16 => ResponseValue::from_response(response).await,
10924            400u16..=499u16 => Err(Error::ErrorResponse(
10925                ResponseValue::from_response(response).await?,
10926            )),
10927            500u16..=599u16 => Err(Error::ErrorResponse(
10928                ResponseValue::from_response(response).await?,
10929            )),
10930            _ => Err(Error::UnexpectedResponse(response)),
10931        }
10932    }
10933
10934    ///Get remote configuration
10935    ///
10936    ///Returns the key/value settings for a single remote.
10937    ///
10938    ///Sends a `POST` request to `/config/get`
10939    ///
10940    ///Arguments:
10941    /// - `async_`: Run the command asynchronously. Returns a job id
10942    ///   immediately.
10943    /// - `group`: Assign the request to a custom stats group.
10944    /// - `name`: Name of the remote configuration to fetch.
10945    pub async fn config_get<'a>(
10946        &'a self,
10947        async_: Option<bool>,
10948        group: Option<&'a str>,
10949        name: &'a str,
10950    ) -> Result<ResponseValue<types::ConfigGetResponse>, Error<types::RcError>> {
10951        let url = format!("{}/config/get", self.baseurl,);
10952        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10953        header_map.append(
10954            ::reqwest::header::HeaderName::from_static("api-version"),
10955            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10956        );
10957        #[allow(unused_mut)]
10958        let mut request = self
10959            .client
10960            .post(url)
10961            .header(
10962                ::reqwest::header::ACCEPT,
10963                ::reqwest::header::HeaderValue::from_static("application/json"),
10964            )
10965            .query(&progenitor_client::QueryParam::new("_async", &async_))
10966            .query(&progenitor_client::QueryParam::new("_group", &group))
10967            .query(&progenitor_client::QueryParam::new("name", &name))
10968            .headers(header_map)
10969            .build()?;
10970        let info = OperationInfo {
10971            operation_id: "config_get",
10972        };
10973        self.pre(&mut request, &info).await?;
10974        let result = self.exec(request, &info).await;
10975        self.post(&result, &info).await?;
10976        let response = result?;
10977        match response.status().as_u16() {
10978            200u16 => ResponseValue::from_response(response).await,
10979            400u16..=499u16 => Err(Error::ErrorResponse(
10980                ResponseValue::from_response(response).await?,
10981            )),
10982            500u16..=599u16 => Err(Error::ErrorResponse(
10983                ResponseValue::from_response(response).await?,
10984            )),
10985            _ => Err(Error::UnexpectedResponse(response)),
10986        }
10987    }
10988
10989    ///List configured remotes
10990    ///
10991    ///Returns the names of all remotes defined in the config file.
10992    ///
10993    ///Sends a `POST` request to `/config/listremotes`
10994    ///
10995    ///Arguments:
10996    /// - `async_`: Run the command asynchronously. Returns a job id
10997    ///   immediately.
10998    /// - `group`: Assign the request to a custom stats group.
10999    pub async fn config_listremotes<'a>(
11000        &'a self,
11001        async_: Option<bool>,
11002        group: Option<&'a str>,
11003    ) -> Result<ResponseValue<types::ConfigListremotesResponse>, Error<types::RcError>> {
11004        let url = format!("{}/config/listremotes", self.baseurl,);
11005        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11006        header_map.append(
11007            ::reqwest::header::HeaderName::from_static("api-version"),
11008            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11009        );
11010        #[allow(unused_mut)]
11011        let mut request = self
11012            .client
11013            .post(url)
11014            .header(
11015                ::reqwest::header::ACCEPT,
11016                ::reqwest::header::HeaderValue::from_static("application/json"),
11017            )
11018            .query(&progenitor_client::QueryParam::new("_async", &async_))
11019            .query(&progenitor_client::QueryParam::new("_group", &group))
11020            .headers(header_map)
11021            .build()?;
11022        let info = OperationInfo {
11023            operation_id: "config_listremotes",
11024        };
11025        self.pre(&mut request, &info).await?;
11026        let result = self.exec(request, &info).await;
11027        self.post(&result, &info).await?;
11028        let response = result?;
11029        match response.status().as_u16() {
11030            200u16 => ResponseValue::from_response(response).await,
11031            400u16..=499u16 => Err(Error::ErrorResponse(
11032                ResponseValue::from_response(response).await?,
11033            )),
11034            500u16..=599u16 => Err(Error::ErrorResponse(
11035                ResponseValue::from_response(response).await?,
11036            )),
11037            _ => Err(Error::UnexpectedResponse(response)),
11038        }
11039    }
11040
11041    ///Update remote secrets
11042    ///
11043    ///Sets obscured password fields for a remote configuration.
11044    ///
11045    ///Sends a `POST` request to `/config/password`
11046    ///
11047    ///Arguments:
11048    /// - `async_`: Run the command asynchronously. Returns a job id
11049    ///   immediately.
11050    /// - `group`: Assign the request to a custom stats group.
11051    /// - `name`: Name of the remote whose secrets should be updated.
11052    /// - `parameters`: JSON object of password answers, typically including
11053    ///   `pass`.
11054    pub async fn config_password<'a>(
11055        &'a self,
11056        async_: Option<bool>,
11057        group: Option<&'a str>,
11058        name: &'a str,
11059        parameters: &'a str,
11060    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
11061        let url = format!("{}/config/password", self.baseurl,);
11062        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11063        header_map.append(
11064            ::reqwest::header::HeaderName::from_static("api-version"),
11065            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11066        );
11067        #[allow(unused_mut)]
11068        let mut request = self
11069            .client
11070            .post(url)
11071            .header(
11072                ::reqwest::header::ACCEPT,
11073                ::reqwest::header::HeaderValue::from_static("application/json"),
11074            )
11075            .query(&progenitor_client::QueryParam::new("_async", &async_))
11076            .query(&progenitor_client::QueryParam::new("_group", &group))
11077            .query(&progenitor_client::QueryParam::new("name", &name))
11078            .query(&progenitor_client::QueryParam::new(
11079                "parameters",
11080                &parameters,
11081            ))
11082            .headers(header_map)
11083            .build()?;
11084        let info = OperationInfo {
11085            operation_id: "config_password",
11086        };
11087        self.pre(&mut request, &info).await?;
11088        let result = self.exec(request, &info).await;
11089        self.post(&result, &info).await?;
11090        let response = result?;
11091        match response.status().as_u16() {
11092            200u16 => Ok(ResponseValue::empty(response)),
11093            400u16..=499u16 => Err(Error::ErrorResponse(
11094                ResponseValue::from_response(response).await?,
11095            )),
11096            500u16..=599u16 => Err(Error::ErrorResponse(
11097                ResponseValue::from_response(response).await?,
11098            )),
11099            _ => Err(Error::UnexpectedResponse(response)),
11100        }
11101    }
11102
11103    ///Show config paths
11104    ///
11105    ///Returns the paths to the config file, cache directory, and temporary
11106    /// directory.
11107    ///
11108    ///Sends a `POST` request to `/config/paths`
11109    ///
11110    ///Arguments:
11111    /// - `async_`: Run the command asynchronously. Returns a job id
11112    ///   immediately.
11113    /// - `group`: Assign the request to a custom stats group.
11114    pub async fn config_paths<'a>(
11115        &'a self,
11116        async_: Option<bool>,
11117        group: Option<&'a str>,
11118    ) -> Result<ResponseValue<types::ConfigPathsResponse>, Error<types::RcError>> {
11119        let url = format!("{}/config/paths", self.baseurl,);
11120        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11121        header_map.append(
11122            ::reqwest::header::HeaderName::from_static("api-version"),
11123            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11124        );
11125        #[allow(unused_mut)]
11126        let mut request = self
11127            .client
11128            .post(url)
11129            .header(
11130                ::reqwest::header::ACCEPT,
11131                ::reqwest::header::HeaderValue::from_static("application/json"),
11132            )
11133            .query(&progenitor_client::QueryParam::new("_async", &async_))
11134            .query(&progenitor_client::QueryParam::new("_group", &group))
11135            .headers(header_map)
11136            .build()?;
11137        let info = OperationInfo {
11138            operation_id: "config_paths",
11139        };
11140        self.pre(&mut request, &info).await?;
11141        let result = self.exec(request, &info).await;
11142        self.post(&result, &info).await?;
11143        let response = result?;
11144        match response.status().as_u16() {
11145            200u16 => ResponseValue::from_response(response).await,
11146            400u16..=499u16 => Err(Error::ErrorResponse(
11147                ResponseValue::from_response(response).await?,
11148            )),
11149            500u16..=599u16 => Err(Error::ErrorResponse(
11150                ResponseValue::from_response(response).await?,
11151            )),
11152            _ => Err(Error::UnexpectedResponse(response)),
11153        }
11154    }
11155
11156    ///List backend providers
11157    ///
11158    ///Returns metadata describing each supported storage provider.
11159    ///
11160    ///Sends a `POST` request to `/config/providers`
11161    ///
11162    ///Arguments:
11163    /// - `async_`: Run the command asynchronously. Returns a job id
11164    ///   immediately.
11165    /// - `group`: Assign the request to a custom stats group.
11166    pub async fn config_providers<'a>(
11167        &'a self,
11168        async_: Option<bool>,
11169        group: Option<&'a str>,
11170    ) -> Result<ResponseValue<types::ConfigProvidersResponse>, Error<types::RcError>> {
11171        let url = format!("{}/config/providers", self.baseurl,);
11172        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11173        header_map.append(
11174            ::reqwest::header::HeaderName::from_static("api-version"),
11175            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11176        );
11177        #[allow(unused_mut)]
11178        let mut request = self
11179            .client
11180            .post(url)
11181            .header(
11182                ::reqwest::header::ACCEPT,
11183                ::reqwest::header::HeaderValue::from_static("application/json"),
11184            )
11185            .query(&progenitor_client::QueryParam::new("_async", &async_))
11186            .query(&progenitor_client::QueryParam::new("_group", &group))
11187            .headers(header_map)
11188            .build()?;
11189        let info = OperationInfo {
11190            operation_id: "config_providers",
11191        };
11192        self.pre(&mut request, &info).await?;
11193        let result = self.exec(request, &info).await;
11194        self.post(&result, &info).await?;
11195        let response = result?;
11196        match response.status().as_u16() {
11197            200u16 => ResponseValue::from_response(response).await,
11198            400u16..=499u16 => Err(Error::ErrorResponse(
11199                ResponseValue::from_response(response).await?,
11200            )),
11201            500u16..=599u16 => Err(Error::ErrorResponse(
11202                ResponseValue::from_response(response).await?,
11203            )),
11204            _ => Err(Error::UnexpectedResponse(response)),
11205        }
11206    }
11207
11208    ///Set config path
11209    ///
11210    ///Points rclone at a specific `rclone.conf` file.
11211    ///
11212    ///Sends a `POST` request to `/config/setpath`
11213    ///
11214    ///Arguments:
11215    /// - `async_`: Run the command asynchronously. Returns a job id
11216    ///   immediately.
11217    /// - `group`: Assign the request to a custom stats group.
11218    /// - `path`: Absolute path to the `rclone.conf` file that rclone should
11219    ///   use.
11220    pub async fn config_setpath<'a>(
11221        &'a self,
11222        async_: Option<bool>,
11223        group: Option<&'a str>,
11224        path: &'a str,
11225    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
11226        let url = format!("{}/config/setpath", self.baseurl,);
11227        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11228        header_map.append(
11229            ::reqwest::header::HeaderName::from_static("api-version"),
11230            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11231        );
11232        #[allow(unused_mut)]
11233        let mut request = self
11234            .client
11235            .post(url)
11236            .header(
11237                ::reqwest::header::ACCEPT,
11238                ::reqwest::header::HeaderValue::from_static("application/json"),
11239            )
11240            .query(&progenitor_client::QueryParam::new("_async", &async_))
11241            .query(&progenitor_client::QueryParam::new("_group", &group))
11242            .query(&progenitor_client::QueryParam::new("path", &path))
11243            .headers(header_map)
11244            .build()?;
11245        let info = OperationInfo {
11246            operation_id: "config_setpath",
11247        };
11248        self.pre(&mut request, &info).await?;
11249        let result = self.exec(request, &info).await;
11250        self.post(&result, &info).await?;
11251        let response = result?;
11252        match response.status().as_u16() {
11253            200u16 => Ok(ResponseValue::empty(response)),
11254            400u16..=499u16 => Err(Error::ErrorResponse(
11255                ResponseValue::from_response(response).await?,
11256            )),
11257            500u16..=599u16 => Err(Error::ErrorResponse(
11258                ResponseValue::from_response(response).await?,
11259            )),
11260            _ => Err(Error::UnexpectedResponse(response)),
11261        }
11262    }
11263
11264    ///Unlock encrypted config
11265    ///
11266    ///Unlocks the configuration file using the provided password.
11267    ///
11268    ///Sends a `POST` request to `/config/unlock`
11269    ///
11270    ///Arguments:
11271    /// - `async_`: Run the command asynchronously. Returns a job id
11272    ///   immediately.
11273    /// - `group`: Assign the request to a custom stats group.
11274    /// - `config_password`: Password used to unlock an encrypted config file.
11275    pub async fn config_unlock<'a>(
11276        &'a self,
11277        async_: Option<bool>,
11278        group: Option<&'a str>,
11279        config_password: &'a str,
11280    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
11281        let url = format!("{}/config/unlock", self.baseurl,);
11282        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11283        header_map.append(
11284            ::reqwest::header::HeaderName::from_static("api-version"),
11285            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11286        );
11287        #[allow(unused_mut)]
11288        let mut request = self
11289            .client
11290            .post(url)
11291            .header(
11292                ::reqwest::header::ACCEPT,
11293                ::reqwest::header::HeaderValue::from_static("application/json"),
11294            )
11295            .query(&progenitor_client::QueryParam::new("_async", &async_))
11296            .query(&progenitor_client::QueryParam::new("_group", &group))
11297            .query(&progenitor_client::QueryParam::new(
11298                "configPassword",
11299                &config_password,
11300            ))
11301            .headers(header_map)
11302            .build()?;
11303        let info = OperationInfo {
11304            operation_id: "config_unlock",
11305        };
11306        self.pre(&mut request, &info).await?;
11307        let result = self.exec(request, &info).await;
11308        self.post(&result, &info).await?;
11309        let response = result?;
11310        match response.status().as_u16() {
11311            200u16 => Ok(ResponseValue::empty(response)),
11312            400u16..=499u16 => Err(Error::ErrorResponse(
11313                ResponseValue::from_response(response).await?,
11314            )),
11315            500u16..=599u16 => Err(Error::ErrorResponse(
11316                ResponseValue::from_response(response).await?,
11317            )),
11318            _ => Err(Error::UnexpectedResponse(response)),
11319        }
11320    }
11321
11322    ///Update remote configuration
11323    ///
11324    ///Updates an existing remote with new parameter values.
11325    ///
11326    ///Sends a `POST` request to `/config/update`
11327    ///
11328    ///Arguments:
11329    /// - `async_`: Run the command asynchronously. Returns a job id
11330    ///   immediately.
11331    /// - `group`: Assign the request to a custom stats group.
11332    /// - `name`: Name of the remote configuration to update.
11333    /// - `opt`: Optional JSON object controlling update behaviour (e.g.
11334    ///   `obscure`, `continue`).
11335    /// - `parameters`: JSON object of configuration key/value pairs to apply to
11336    ///   the remote.
11337    pub async fn config_update<'a>(
11338        &'a self,
11339        async_: Option<bool>,
11340        group: Option<&'a str>,
11341        name: &'a str,
11342        opt: Option<&'a str>,
11343        parameters: &'a str,
11344    ) -> Result<
11345        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11346        Error<types::RcError>,
11347    > {
11348        let url = format!("{}/config/update", self.baseurl,);
11349        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11350        header_map.append(
11351            ::reqwest::header::HeaderName::from_static("api-version"),
11352            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11353        );
11354        #[allow(unused_mut)]
11355        let mut request = self
11356            .client
11357            .post(url)
11358            .header(
11359                ::reqwest::header::ACCEPT,
11360                ::reqwest::header::HeaderValue::from_static("application/json"),
11361            )
11362            .query(&progenitor_client::QueryParam::new("_async", &async_))
11363            .query(&progenitor_client::QueryParam::new("_group", &group))
11364            .query(&progenitor_client::QueryParam::new("name", &name))
11365            .query(&progenitor_client::QueryParam::new("opt", &opt))
11366            .query(&progenitor_client::QueryParam::new(
11367                "parameters",
11368                &parameters,
11369            ))
11370            .headers(header_map)
11371            .build()?;
11372        let info = OperationInfo {
11373            operation_id: "config_update",
11374        };
11375        self.pre(&mut request, &info).await?;
11376        let result = self.exec(request, &info).await;
11377        self.post(&result, &info).await?;
11378        let response = result?;
11379        match response.status().as_u16() {
11380            200u16 => ResponseValue::from_response(response).await,
11381            400u16..=499u16 => Err(Error::ErrorResponse(
11382                ResponseValue::from_response(response).await?,
11383            )),
11384            500u16..=599u16 => Err(Error::ErrorResponse(
11385                ResponseValue::from_response(response).await?,
11386            )),
11387            _ => Err(Error::UnexpectedResponse(response)),
11388        }
11389    }
11390
11391    ///Report rclone version
11392    ///
11393    ///Returns the running rclone version, build metadata, and Go runtime
11394    /// details.
11395    ///
11396    ///Sends a `POST` request to `/core/version`
11397    ///
11398    ///Arguments:
11399    /// - `async_`: Run the command asynchronously. Returns a job id
11400    ///   immediately.
11401    /// - `group`: Assign the request to a custom stats group.
11402    pub async fn core_version<'a>(
11403        &'a self,
11404        async_: Option<bool>,
11405        group: Option<&'a str>,
11406    ) -> Result<ResponseValue<types::CoreVersionResponse>, Error<types::RcError>> {
11407        let url = format!("{}/core/version", self.baseurl,);
11408        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11409        header_map.append(
11410            ::reqwest::header::HeaderName::from_static("api-version"),
11411            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11412        );
11413        #[allow(unused_mut)]
11414        let mut request = self
11415            .client
11416            .post(url)
11417            .header(
11418                ::reqwest::header::ACCEPT,
11419                ::reqwest::header::HeaderValue::from_static("application/json"),
11420            )
11421            .query(&progenitor_client::QueryParam::new("_async", &async_))
11422            .query(&progenitor_client::QueryParam::new("_group", &group))
11423            .headers(header_map)
11424            .build()?;
11425        let info = OperationInfo {
11426            operation_id: "core_version",
11427        };
11428        self.pre(&mut request, &info).await?;
11429        let result = self.exec(request, &info).await;
11430        self.post(&result, &info).await?;
11431        let response = result?;
11432        match response.status().as_u16() {
11433            200u16 => ResponseValue::from_response(response).await,
11434            400u16..=499u16 => Err(Error::ErrorResponse(
11435                ResponseValue::from_response(response).await?,
11436            )),
11437            500u16..=599u16 => Err(Error::ErrorResponse(
11438                ResponseValue::from_response(response).await?,
11439            )),
11440            _ => Err(Error::UnexpectedResponse(response)),
11441        }
11442    }
11443
11444    ///Current stats snapshot
11445    ///
11446    ///Returns active transfer statistics including bytes transferred, speed,
11447    /// and error counts.
11448    ///
11449    ///Sends a `POST` request to `/core/stats`
11450    ///
11451    ///Arguments:
11452    /// - `async_`: Run the command asynchronously. Returns a job id
11453    ///   immediately.
11454    /// - `group`: Assign the request to a custom stats group.
11455    /// - `group`: Stats group identifier to return a snapshot for. Leave unset
11456    ///   to include all groups.
11457    /// - `short`: When true, omit the `transferring` and `checking` arrays from
11458    ///   the response.
11459    pub async fn core_stats<'a>(
11460        &'a self,
11461        async_: Option<bool>,
11462        _group: Option<&'a str>,
11463        group: Option<&'a str>,
11464        short: Option<bool>
11465    ) -> Result<ResponseValue<types::CoreStatsResponse>, Error<types::RcError>> {
11466        let url = format!("{}/core/stats", self.baseurl,);
11467        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11468        header_map.append(
11469            ::reqwest::header::HeaderName::from_static("api-version"),
11470            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11471        );
11472        #[allow(unused_mut)]
11473        let mut request = self
11474            .client
11475            .post(url)
11476            .header(
11477                ::reqwest::header::ACCEPT,
11478                ::reqwest::header::HeaderValue::from_static("application/json"),
11479            )
11480            .query(&progenitor_client::QueryParam::new("_async", &async_))
11481            .query(&progenitor_client::QueryParam::new("_group", &group))
11482            .query(&progenitor_client::QueryParam::new("group", &group))
11483            .query(&progenitor_client::QueryParam::new("short", &short))
11484            .headers(header_map)
11485            .build()?;
11486        let info = OperationInfo {
11487            operation_id: "core_stats",
11488        };
11489        self.pre(&mut request, &info).await?;
11490        let result = self.exec(request, &info).await;
11491        self.post(&result, &info).await?;
11492        let response = result?;
11493        match response.status().as_u16() {
11494            200u16 => ResponseValue::from_response(response).await,
11495            400u16..=499u16 => Err(Error::ErrorResponse(
11496                ResponseValue::from_response(response).await?,
11497            )),
11498            500u16..=599u16 => Err(Error::ErrorResponse(
11499                ResponseValue::from_response(response).await?,
11500            )),
11501            _ => Err(Error::UnexpectedResponse(response)),
11502        }
11503    }
11504
11505    ///Run batch of commands
11506    ///
11507    ///Run a batch of rclone rc commands concurrently.
11508    ///
11509    ///Sends a `POST` request to `/job/batch`
11510    ///
11511    ///Arguments:
11512    /// - `async_`: Run the command asynchronously. Returns a job id
11513    ///   immediately.
11514    /// - `concurrency`: Do this many commands concurrently. Defaults to
11515    ///   --transfers if not set.
11516    /// - `inputs`: List of inputs to the commands with an extra _path
11517    ///   parameter.
11518    /// - `body`
11519    pub async fn job_batch<'a>(
11520        &'a self,
11521        async_: Option<bool>,
11522        concurrency: Option<i64>,
11523        inputs: Option<&'a ::std::vec::Vec<types::JobBatchInputsItem>>,
11524        body: &'a types::JobBatchRequest,
11525    ) -> Result<ResponseValue<types::JobBatchResponse>, Error<types::RcError>> {
11526        let url = format!("{}/job/batch", self.baseurl,);
11527        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11528        header_map.append(
11529            ::reqwest::header::HeaderName::from_static("api-version"),
11530            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11531        );
11532        #[allow(unused_mut)]
11533        let mut request = self
11534            .client
11535            .post(url)
11536            .header(
11537                ::reqwest::header::ACCEPT,
11538                ::reqwest::header::HeaderValue::from_static("application/json"),
11539            )
11540            .json(&body)
11541            .query(&progenitor_client::QueryParam::new("_async", &async_))
11542            .query(&progenitor_client::QueryParam::new(
11543                "concurrency",
11544                &concurrency,
11545            ))
11546            .query(&progenitor_client::QueryParam::new("inputs", &inputs))
11547            .headers(header_map)
11548            .build()?;
11549        let info = OperationInfo {
11550            operation_id: "job_batch",
11551        };
11552        self.pre(&mut request, &info).await?;
11553        let result = self.exec(request, &info).await;
11554        self.post(&result, &info).await?;
11555        let response = result?;
11556        match response.status().as_u16() {
11557            200u16 => ResponseValue::from_response(response).await,
11558            400u16..=499u16 => Err(Error::ErrorResponse(
11559                ResponseValue::from_response(response).await?,
11560            )),
11561            500u16..=599u16 => Err(Error::ErrorResponse(
11562                ResponseValue::from_response(response).await?,
11563            )),
11564            _ => Err(Error::UnexpectedResponse(response)),
11565        }
11566    }
11567
11568    ///List jobs
11569    ///
11570    ///Returns identifiers of active and recently completed asynchronous jobs.
11571    ///
11572    ///Sends a `POST` request to `/job/list`
11573    ///
11574    ///Arguments:
11575    /// - `async_`: Run the command asynchronously. Returns a job id
11576    ///   immediately.
11577    pub async fn job_list<'a>(
11578        &'a self,
11579        async_: Option<bool>,
11580    ) -> Result<ResponseValue<types::JobListResponse>, Error<types::RcError>> {
11581        let url = format!("{}/job/list", self.baseurl,);
11582        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11583        header_map.append(
11584            ::reqwest::header::HeaderName::from_static("api-version"),
11585            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11586        );
11587        #[allow(unused_mut)]
11588        let mut request = self
11589            .client
11590            .post(url)
11591            .header(
11592                ::reqwest::header::ACCEPT,
11593                ::reqwest::header::HeaderValue::from_static("application/json"),
11594            )
11595            .query(&progenitor_client::QueryParam::new("_async", &async_))
11596            .headers(header_map)
11597            .build()?;
11598        let info = OperationInfo {
11599            operation_id: "job_list",
11600        };
11601        self.pre(&mut request, &info).await?;
11602        let result = self.exec(request, &info).await;
11603        self.post(&result, &info).await?;
11604        let response = result?;
11605        match response.status().as_u16() {
11606            200u16 => ResponseValue::from_response(response).await,
11607            400u16..=499u16 => Err(Error::ErrorResponse(
11608                ResponseValue::from_response(response).await?,
11609            )),
11610            500u16..=599u16 => Err(Error::ErrorResponse(
11611                ResponseValue::from_response(response).await?,
11612            )),
11613            _ => Err(Error::UnexpectedResponse(response)),
11614        }
11615    }
11616
11617    ///Get job status
11618    ///
11619    ///Returns timing, success state, output, and progress for a specific job.
11620    ///
11621    ///Sends a `POST` request to `/job/status`
11622    ///
11623    ///Arguments:
11624    /// - `async_`: Run the command asynchronously. Returns a job id
11625    ///   immediately.
11626    /// - `jobid`: Numeric identifier of the job to query, as returned from an
11627    ///   async call.
11628    pub async fn job_status<'a>(
11629        &'a self,
11630        async_: Option<bool>,
11631        jobid: f64,
11632    ) -> Result<ResponseValue<types::JobStatusResponse>, Error<types::RcError>> {
11633        let url = format!("{}/job/status", self.baseurl,);
11634        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11635        header_map.append(
11636            ::reqwest::header::HeaderName::from_static("api-version"),
11637            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11638        );
11639        #[allow(unused_mut)]
11640        let mut request = self
11641            .client
11642            .post(url)
11643            .header(
11644                ::reqwest::header::ACCEPT,
11645                ::reqwest::header::HeaderValue::from_static("application/json"),
11646            )
11647            .query(&progenitor_client::QueryParam::new("_async", &async_))
11648            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
11649            .headers(header_map)
11650            .build()?;
11651        let info = OperationInfo {
11652            operation_id: "job_status",
11653        };
11654        self.pre(&mut request, &info).await?;
11655        let result = self.exec(request, &info).await;
11656        self.post(&result, &info).await?;
11657        let response = result?;
11658        match response.status().as_u16() {
11659            200u16 => ResponseValue::from_response(response).await,
11660            400u16..=499u16 => Err(Error::ErrorResponse(
11661                ResponseValue::from_response(response).await?,
11662            )),
11663            500u16..=599u16 => Err(Error::ErrorResponse(
11664                ResponseValue::from_response(response).await?,
11665            )),
11666            _ => Err(Error::UnexpectedResponse(response)),
11667        }
11668    }
11669
11670    ///Stop job
11671    ///
11672    ///Attempts to cancel a running job by ID.
11673    ///
11674    ///Sends a `POST` request to `/job/stop`
11675    ///
11676    ///Arguments:
11677    /// - `async_`: Run the command asynchronously. Returns a job id
11678    ///   immediately.
11679    /// - `jobid`: Numeric identifier of the job to cancel.
11680    pub async fn job_stop<'a>(
11681        &'a self,
11682        async_: Option<bool>,
11683        jobid: f64,
11684    ) -> Result<
11685        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11686        Error<types::RcError>,
11687    > {
11688        let url = format!("{}/job/stop", self.baseurl,);
11689        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11690        header_map.append(
11691            ::reqwest::header::HeaderName::from_static("api-version"),
11692            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11693        );
11694        #[allow(unused_mut)]
11695        let mut request = self
11696            .client
11697            .post(url)
11698            .header(
11699                ::reqwest::header::ACCEPT,
11700                ::reqwest::header::HeaderValue::from_static("application/json"),
11701            )
11702            .query(&progenitor_client::QueryParam::new("_async", &async_))
11703            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
11704            .headers(header_map)
11705            .build()?;
11706        let info = OperationInfo {
11707            operation_id: "job_stop",
11708        };
11709        self.pre(&mut request, &info).await?;
11710        let result = self.exec(request, &info).await;
11711        self.post(&result, &info).await?;
11712        let response = result?;
11713        match response.status().as_u16() {
11714            200u16 => ResponseValue::from_response(response).await,
11715            400u16..=499u16 => Err(Error::ErrorResponse(
11716                ResponseValue::from_response(response).await?,
11717            )),
11718            500u16..=599u16 => Err(Error::ErrorResponse(
11719                ResponseValue::from_response(response).await?,
11720            )),
11721            _ => Err(Error::UnexpectedResponse(response)),
11722        }
11723    }
11724
11725    ///Stop jobs in group
11726    ///
11727    ///Cancels all active jobs associated with the provided stats group.
11728    ///
11729    ///Sends a `POST` request to `/job/stopgroup`
11730    ///
11731    ///Arguments:
11732    /// - `async_`: Run the command asynchronously. Returns a job id
11733    ///   immediately.
11734    /// - `group`: Stats group name whose active jobs should be stopped.
11735    pub async fn job_stopgroup<'a>(
11736        &'a self,
11737        async_: Option<bool>,
11738        group: &'a str,
11739    ) -> Result<
11740        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11741        Error<types::RcError>,
11742    > {
11743        let url = format!("{}/job/stopgroup", self.baseurl,);
11744        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11745        header_map.append(
11746            ::reqwest::header::HeaderName::from_static("api-version"),
11747            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11748        );
11749        #[allow(unused_mut)]
11750        let mut request = self
11751            .client
11752            .post(url)
11753            .header(
11754                ::reqwest::header::ACCEPT,
11755                ::reqwest::header::HeaderValue::from_static("application/json"),
11756            )
11757            .query(&progenitor_client::QueryParam::new("_async", &async_))
11758            .query(&progenitor_client::QueryParam::new("group", &group))
11759            .headers(header_map)
11760            .build()?;
11761        let info = OperationInfo {
11762            operation_id: "job_stopgroup",
11763        };
11764        self.pre(&mut request, &info).await?;
11765        let result = self.exec(request, &info).await;
11766        self.post(&result, &info).await?;
11767        let response = result?;
11768        match response.status().as_u16() {
11769            200u16 => ResponseValue::from_response(response).await,
11770            400u16..=499u16 => Err(Error::ErrorResponse(
11771                ResponseValue::from_response(response).await?,
11772            )),
11773            500u16..=599u16 => Err(Error::ErrorResponse(
11774                ResponseValue::from_response(response).await?,
11775            )),
11776            _ => Err(Error::UnexpectedResponse(response)),
11777        }
11778    }
11779
11780    ///List objects
11781    ///
11782    ///Lists objects and directories for a remote path, returning the same
11783    /// fields as `rclone lsjson`.
11784    ///
11785    ///Sends a `POST` request to `/operations/list`
11786    ///
11787    ///Arguments:
11788    /// - `async_`: Run the command asynchronously. Returns a job id
11789    ///   immediately.
11790    /// - `group`: Assign the request to a custom stats group.
11791    /// - `dirs_only`: Set to true to return only directory entries.
11792    /// - `files_only`: Set to true to return only file entries.
11793    /// - `fs`: Remote name or path to list, for example `drive:`.
11794    /// - `hash_types`: Specify one or more hash algorithms to include when
11795    ///   `showHash` is true (e.g. `md5`).
11796    /// - `metadata`: Set to true to include backend-provided metadata maps.
11797    /// - `no_mime_type`: Set to true to omit MIME type detection.
11798    /// - `no_mod_time`: Set to true to omit modification times for faster
11799    ///   listings on some backends.
11800    /// - `opt`: Optional JSON-encoded object of listing flags (e.g. `{
11801    ///   "recurse": true, "showHash": true }`).
11802    /// - `recurse`: Set to true to list directories recursively.
11803    /// - `remote`: Directory path within `fs` to list; leave empty to target
11804    ///   the root.
11805    /// - `show_encrypted`: Set to true to include encrypted names when using
11806    ///   crypt remotes.
11807    /// - `show_hash`: Set to true to include hash digests for each entry.
11808    /// - `show_orig_i_ds`: Set to true to include original backend identifiers
11809    ///   where available.
11810    pub async fn operations_list<'a>(
11811        &'a self,
11812        async_: Option<bool>,
11813        group: Option<&'a str>,
11814        dirs_only: Option<bool>,
11815        files_only: Option<bool>,
11816        fs: &'a str,
11817        hash_types: Option<&'a ::std::vec::Vec<::std::string::String>>,
11818        metadata: Option<bool>,
11819        no_mime_type: Option<bool>,
11820        no_mod_time: Option<bool>,
11821        opt: Option<&'a str>,
11822        recurse: Option<bool>,
11823        remote: &'a str,
11824        show_encrypted: Option<bool>,
11825        show_hash: Option<bool>,
11826        show_orig_i_ds: Option<bool>,
11827    ) -> Result<ResponseValue<types::OperationsListResponse>, Error<types::RcError>> {
11828        let url = format!("{}/operations/list", self.baseurl,);
11829        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11830        header_map.append(
11831            ::reqwest::header::HeaderName::from_static("api-version"),
11832            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11833        );
11834        #[allow(unused_mut)]
11835        let mut request = self
11836            .client
11837            .post(url)
11838            .header(
11839                ::reqwest::header::ACCEPT,
11840                ::reqwest::header::HeaderValue::from_static("application/json"),
11841            )
11842            .query(&progenitor_client::QueryParam::new("_async", &async_))
11843            .query(&progenitor_client::QueryParam::new("_group", &group))
11844            .query(&progenitor_client::QueryParam::new("dirsOnly", &dirs_only))
11845            .query(&progenitor_client::QueryParam::new(
11846                "filesOnly",
11847                &files_only,
11848            ))
11849            .query(&progenitor_client::QueryParam::new("fs", &fs))
11850            .query(&progenitor_client::QueryParam::new(
11851                "hashTypes",
11852                &hash_types,
11853            ))
11854            .query(&progenitor_client::QueryParam::new("metadata", &metadata))
11855            .query(&progenitor_client::QueryParam::new(
11856                "noMimeType",
11857                &no_mime_type,
11858            ))
11859            .query(&progenitor_client::QueryParam::new(
11860                "noModTime",
11861                &no_mod_time,
11862            ))
11863            .query(&progenitor_client::QueryParam::new("opt", &opt))
11864            .query(&progenitor_client::QueryParam::new("recurse", &recurse))
11865            .query(&progenitor_client::QueryParam::new("remote", &remote))
11866            .query(&progenitor_client::QueryParam::new(
11867                "showEncrypted",
11868                &show_encrypted,
11869            ))
11870            .query(&progenitor_client::QueryParam::new("showHash", &show_hash))
11871            .query(&progenitor_client::QueryParam::new(
11872                "showOrigIDs",
11873                &show_orig_i_ds,
11874            ))
11875            .headers(header_map)
11876            .build()?;
11877        let info = OperationInfo {
11878            operation_id: "operations_list",
11879        };
11880        self.pre(&mut request, &info).await?;
11881        let result = self.exec(request, &info).await;
11882        self.post(&result, &info).await?;
11883        let response = result?;
11884        match response.status().as_u16() {
11885            200u16 => ResponseValue::from_response(response).await,
11886            400u16..=499u16 => Err(Error::ErrorResponse(
11887                ResponseValue::from_response(response).await?,
11888            )),
11889            500u16..=599u16 => Err(Error::ErrorResponse(
11890                ResponseValue::from_response(response).await?,
11891            )),
11892            _ => Err(Error::UnexpectedResponse(response)),
11893        }
11894    }
11895
11896    ///Stat an object
11897    ///
11898    ///Returns metadata for a single file or directory, mirroring `rclone
11899    /// lsjson` on one entry.
11900    ///
11901    ///Sends a `POST` request to `/operations/stat`
11902    ///
11903    ///Arguments:
11904    /// - `async_`: Run the command asynchronously. Returns a job id
11905    ///   immediately.
11906    /// - `group`: Assign the request to a custom stats group.
11907    /// - `fs`: Remote name or path that contains the item to inspect.
11908    /// - `opt`: Optional JSON object of listing flags, matching those accepted
11909    ///   by `operations/list`.
11910    /// - `remote`: Path to the file or directory within `fs` to describe.
11911    pub async fn operations_stat<'a>(
11912        &'a self,
11913        async_: Option<bool>,
11914        group: Option<&'a str>,
11915        fs: &'a str,
11916        opt: Option<&'a str>,
11917        remote: &'a str,
11918    ) -> Result<ResponseValue<types::OperationsStatResponse>, Error<types::RcError>> {
11919        let url = format!("{}/operations/stat", self.baseurl,);
11920        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11921        header_map.append(
11922            ::reqwest::header::HeaderName::from_static("api-version"),
11923            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11924        );
11925        #[allow(unused_mut)]
11926        let mut request = self
11927            .client
11928            .post(url)
11929            .header(
11930                ::reqwest::header::ACCEPT,
11931                ::reqwest::header::HeaderValue::from_static("application/json"),
11932            )
11933            .query(&progenitor_client::QueryParam::new("_async", &async_))
11934            .query(&progenitor_client::QueryParam::new("_group", &group))
11935            .query(&progenitor_client::QueryParam::new("fs", &fs))
11936            .query(&progenitor_client::QueryParam::new("opt", &opt))
11937            .query(&progenitor_client::QueryParam::new("remote", &remote))
11938            .headers(header_map)
11939            .build()?;
11940        let info = OperationInfo {
11941            operation_id: "operations_stat",
11942        };
11943        self.pre(&mut request, &info).await?;
11944        let result = self.exec(request, &info).await;
11945        self.post(&result, &info).await?;
11946        let response = result?;
11947        match response.status().as_u16() {
11948            200u16 => ResponseValue::from_response(response).await,
11949            400u16..=499u16 => Err(Error::ErrorResponse(
11950                ResponseValue::from_response(response).await?,
11951            )),
11952            500u16..=599u16 => Err(Error::ErrorResponse(
11953                ResponseValue::from_response(response).await?,
11954            )),
11955            _ => Err(Error::UnexpectedResponse(response)),
11956        }
11957    }
11958
11959    ///Get remote quota
11960    ///
11961    ///Returns storage quota and usage details for the remote, equivalent to
11962    /// `rclone about`.
11963    ///
11964    ///Sends a `POST` request to `/operations/about`
11965    ///
11966    ///Arguments:
11967    /// - `async_`: Run the command asynchronously. Returns a job id
11968    ///   immediately.
11969    /// - `group`: Assign the request to a custom stats group.
11970    /// - `fs`: Remote name or path to query for capacity information.
11971    pub async fn operations_about<'a>(
11972        &'a self,
11973        async_: Option<bool>,
11974        group: Option<&'a str>,
11975        fs: &'a str,
11976    ) -> Result<ResponseValue<types::OperationsAboutResponse>, Error<types::RcError>> {
11977        let url = format!("{}/operations/about", self.baseurl,);
11978        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11979        header_map.append(
11980            ::reqwest::header::HeaderName::from_static("api-version"),
11981            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11982        );
11983        #[allow(unused_mut)]
11984        let mut request = self
11985            .client
11986            .post(url)
11987            .header(
11988                ::reqwest::header::ACCEPT,
11989                ::reqwest::header::HeaderValue::from_static("application/json"),
11990            )
11991            .query(&progenitor_client::QueryParam::new("_async", &async_))
11992            .query(&progenitor_client::QueryParam::new("_group", &group))
11993            .query(&progenitor_client::QueryParam::new("fs", &fs))
11994            .headers(header_map)
11995            .build()?;
11996        let info = OperationInfo {
11997            operation_id: "operations_about",
11998        };
11999        self.pre(&mut request, &info).await?;
12000        let result = self.exec(request, &info).await;
12001        self.post(&result, &info).await?;
12002        let response = result?;
12003        match response.status().as_u16() {
12004            200u16 => ResponseValue::from_response(response).await,
12005            400u16..=499u16 => Err(Error::ErrorResponse(
12006                ResponseValue::from_response(response).await?,
12007            )),
12008            500u16..=599u16 => Err(Error::ErrorResponse(
12009                ResponseValue::from_response(response).await?,
12010            )),
12011            _ => Err(Error::UnexpectedResponse(response)),
12012        }
12013    }
12014
12015    ///Upload files via multipart
12016    ///
12017    ///Accepts multipart/form-data payloads and writes the uploaded files to
12018    /// the specified remote path.
12019    ///
12020    ///Sends a `POST` request to `/operations/uploadfile`
12021    ///
12022    ///Arguments:
12023    /// - `async_`: Run the command asynchronously. Returns a job id
12024    ///   immediately.
12025    /// - `group`: Assign the request to a custom stats group.
12026    /// - `fs`: Remote name or path where the uploaded file should be stored.
12027    /// - `remote`: Destination path within `fs` for the uploaded file.
12028    /// - `body`: Multipart form payload containing one or more files to upload.
12029    pub async fn operations_uploadfile<'a, B: Into<reqwest::Body>>(
12030        &'a self,
12031        async_: Option<bool>,
12032        group: Option<&'a str>,
12033        fs: &'a str,
12034        remote: &'a str,
12035        body: B,
12036    ) -> Result<
12037        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12038        Error<types::RcError>,
12039    > {
12040        let url = format!("{}/operations/uploadfile", self.baseurl,);
12041        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12042        header_map.append(
12043            ::reqwest::header::HeaderName::from_static("api-version"),
12044            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12045        );
12046        #[allow(unused_mut)]
12047        let mut request = self
12048            .client
12049            .post(url)
12050            .header(
12051                ::reqwest::header::ACCEPT,
12052                ::reqwest::header::HeaderValue::from_static("application/json"),
12053            )
12054            .header(
12055                ::reqwest::header::CONTENT_TYPE,
12056                ::reqwest::header::HeaderValue::from_static("application/octet-stream"),
12057            )
12058            .body(body)
12059            .query(&progenitor_client::QueryParam::new("_async", &async_))
12060            .query(&progenitor_client::QueryParam::new("_group", &group))
12061            .query(&progenitor_client::QueryParam::new("fs", &fs))
12062            .query(&progenitor_client::QueryParam::new("remote", &remote))
12063            .headers(header_map)
12064            .build()?;
12065        let info = OperationInfo {
12066            operation_id: "operations_uploadfile",
12067        };
12068        self.pre(&mut request, &info).await?;
12069        let result = self.exec(request, &info).await;
12070        self.post(&result, &info).await?;
12071        let response = result?;
12072        match response.status().as_u16() {
12073            200u16 => ResponseValue::from_response(response).await,
12074            400u16..=499u16 => Err(Error::ErrorResponse(
12075                ResponseValue::from_response(response).await?,
12076            )),
12077            500u16..=599u16 => Err(Error::ErrorResponse(
12078                ResponseValue::from_response(response).await?,
12079            )),
12080            _ => Err(Error::UnexpectedResponse(response)),
12081        }
12082    }
12083
12084    ///Purge directory
12085    ///
12086    ///Deletes a directory or container and all of its contents.
12087    ///
12088    ///Sends a `POST` request to `/operations/purge`
12089    ///
12090    ///Arguments:
12091    /// - `async_`: Run the command asynchronously. Returns a job id
12092    ///   immediately.
12093    /// - `config`: JSON encoded config overrides applied for this call only.
12094    /// - `filter`: JSON encoded filter overrides applied for this call only.
12095    /// - `group`: Assign the request to a custom stats group.
12096    /// - `fs`: Remote name or path from which to remove all contents.
12097    /// - `remote`: Path within `fs` whose contents should be purged.
12098    pub async fn operations_purge<'a>(
12099        &'a self,
12100        async_: Option<bool>,
12101        config: Option<&'a str>,
12102        filter: Option<&'a str>,
12103        group: Option<&'a str>,
12104        fs: &'a str,
12105        remote: &'a str,
12106    ) -> Result<
12107        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12108        Error<types::RcError>,
12109    > {
12110        let url = format!("{}/operations/purge", self.baseurl,);
12111        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12112        header_map.append(
12113            ::reqwest::header::HeaderName::from_static("api-version"),
12114            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12115        );
12116        #[allow(unused_mut)]
12117        let mut request = self
12118            .client
12119            .post(url)
12120            .header(
12121                ::reqwest::header::ACCEPT,
12122                ::reqwest::header::HeaderValue::from_static("application/json"),
12123            )
12124            .query(&progenitor_client::QueryParam::new("_async", &async_))
12125            .query(&progenitor_client::QueryParam::new("_config", &config))
12126            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12127            .query(&progenitor_client::QueryParam::new("_group", &group))
12128            .query(&progenitor_client::QueryParam::new("fs", &fs))
12129            .query(&progenitor_client::QueryParam::new("remote", &remote))
12130            .headers(header_map)
12131            .build()?;
12132        let info = OperationInfo {
12133            operation_id: "operations_purge",
12134        };
12135        self.pre(&mut request, &info).await?;
12136        let result = self.exec(request, &info).await;
12137        self.post(&result, &info).await?;
12138        let response = result?;
12139        match response.status().as_u16() {
12140            200u16 => ResponseValue::from_response(response).await,
12141            400u16..=499u16 => Err(Error::ErrorResponse(
12142                ResponseValue::from_response(response).await?,
12143            )),
12144            500u16..=599u16 => Err(Error::ErrorResponse(
12145                ResponseValue::from_response(response).await?,
12146            )),
12147            _ => Err(Error::UnexpectedResponse(response)),
12148        }
12149    }
12150
12151    ///Create directory
12152    ///
12153    ///Creates the target directory or container if it does not exist.
12154    ///
12155    ///Sends a `POST` request to `/operations/mkdir`
12156    ///
12157    ///Arguments:
12158    /// - `async_`: Run the command asynchronously. Returns a job id
12159    ///   immediately.
12160    /// - `group`: Assign the request to a custom stats group.
12161    /// - `fs`: Remote name or path in which to create a directory.
12162    /// - `remote`: Directory path within `fs` to create.
12163    pub async fn operations_mkdir<'a>(
12164        &'a self,
12165        async_: Option<bool>,
12166        group: Option<&'a str>,
12167        fs: &'a str,
12168        remote: &'a str,
12169    ) -> Result<
12170        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12171        Error<types::RcError>,
12172    > {
12173        let url = format!("{}/operations/mkdir", self.baseurl,);
12174        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12175        header_map.append(
12176            ::reqwest::header::HeaderName::from_static("api-version"),
12177            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12178        );
12179        #[allow(unused_mut)]
12180        let mut request = self
12181            .client
12182            .post(url)
12183            .header(
12184                ::reqwest::header::ACCEPT,
12185                ::reqwest::header::HeaderValue::from_static("application/json"),
12186            )
12187            .query(&progenitor_client::QueryParam::new("_async", &async_))
12188            .query(&progenitor_client::QueryParam::new("_group", &group))
12189            .query(&progenitor_client::QueryParam::new("fs", &fs))
12190            .query(&progenitor_client::QueryParam::new("remote", &remote))
12191            .headers(header_map)
12192            .build()?;
12193        let info = OperationInfo {
12194            operation_id: "operations_mkdir",
12195        };
12196        self.pre(&mut request, &info).await?;
12197        let result = self.exec(request, &info).await;
12198        self.post(&result, &info).await?;
12199        let response = result?;
12200        match response.status().as_u16() {
12201            200u16 => ResponseValue::from_response(response).await,
12202            400u16..=499u16 => Err(Error::ErrorResponse(
12203                ResponseValue::from_response(response).await?,
12204            )),
12205            500u16..=599u16 => Err(Error::ErrorResponse(
12206                ResponseValue::from_response(response).await?,
12207            )),
12208            _ => Err(Error::UnexpectedResponse(response)),
12209        }
12210    }
12211
12212    ///Remove empty directory
12213    ///
12214    ///Deletes an empty directory or container.
12215    ///
12216    ///Sends a `POST` request to `/operations/rmdir`
12217    ///
12218    ///Arguments:
12219    /// - `async_`: Run the command asynchronously. Returns a job id
12220    ///   immediately.
12221    /// - `group`: Assign the request to a custom stats group.
12222    /// - `fs`: Remote name or path containing the directory to remove.
12223    /// - `remote`: Directory path within `fs` to delete.
12224    pub async fn operations_rmdir<'a>(
12225        &'a self,
12226        async_: Option<bool>,
12227        group: Option<&'a str>,
12228        fs: &'a str,
12229        remote: &'a str,
12230    ) -> Result<
12231        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12232        Error<types::RcError>,
12233    > {
12234        let url = format!("{}/operations/rmdir", self.baseurl,);
12235        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12236        header_map.append(
12237            ::reqwest::header::HeaderName::from_static("api-version"),
12238            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12239        );
12240        #[allow(unused_mut)]
12241        let mut request = self
12242            .client
12243            .post(url)
12244            .header(
12245                ::reqwest::header::ACCEPT,
12246                ::reqwest::header::HeaderValue::from_static("application/json"),
12247            )
12248            .query(&progenitor_client::QueryParam::new("_async", &async_))
12249            .query(&progenitor_client::QueryParam::new("_group", &group))
12250            .query(&progenitor_client::QueryParam::new("fs", &fs))
12251            .query(&progenitor_client::QueryParam::new("remote", &remote))
12252            .headers(header_map)
12253            .build()?;
12254        let info = OperationInfo {
12255            operation_id: "operations_rmdir",
12256        };
12257        self.pre(&mut request, &info).await?;
12258        let result = self.exec(request, &info).await;
12259        self.post(&result, &info).await?;
12260        let response = result?;
12261        match response.status().as_u16() {
12262            200u16 => ResponseValue::from_response(response).await,
12263            400u16..=499u16 => Err(Error::ErrorResponse(
12264                ResponseValue::from_response(response).await?,
12265            )),
12266            500u16..=599u16 => Err(Error::ErrorResponse(
12267                ResponseValue::from_response(response).await?,
12268            )),
12269            _ => Err(Error::UnexpectedResponse(response)),
12270        }
12271    }
12272
12273    ///Compare source and destination
12274    ///
12275    ///Compares source and destination trees, reporting matches, differences,
12276    /// and missing files.
12277    ///
12278    ///Sends a `POST` request to `/operations/check`
12279    ///
12280    ///Arguments:
12281    /// - `async_`: Run the command asynchronously. Returns a job id
12282    ///   immediately.
12283    /// - `group`: Assign the request to a custom stats group.
12284    /// - `check_file_fs`: Remote containing the checksum SUM file when using
12285    ///   `checkFileHash`.
12286    /// - `check_file_hash`: Hash name to expect in the supplied SUM file, such
12287    ///   as `md5`.
12288    /// - `check_file_remote`: Path within `checkFileFs` to the checksum SUM
12289    ///   file.
12290    /// - `combined`: Set to true to include a combined summary report in the
12291    ///   response.
12292    /// - `differ`: Set to true to include differing files in the report.
12293    /// - `download`: Set to true to read file contents during comparison
12294    ///   instead of relying on hashes.
12295    /// - `dst_fs`: Destination remote name or path that should match the
12296    ///   source.
12297    /// - `error`: Set to true to include entries that encountered errors.
12298    /// - `match_`: Set to true to include matching files in the report.
12299    /// - `missing_on_dst`: Set to true to report files missing from the
12300    ///   destination.
12301    /// - `missing_on_src`: Set to true to report files missing from the source.
12302    /// - `one_way`: Set to true to only ensure that source files exist on the
12303    ///   destination.
12304    /// - `src_fs`: Source remote name or path to verify, e.g. `drive:`.
12305    pub async fn operations_check<'a>(
12306        &'a self,
12307        async_: Option<bool>,
12308        group: Option<&'a str>,
12309        check_file_fs: Option<&'a str>,
12310        check_file_hash: Option<&'a str>,
12311        check_file_remote: Option<&'a str>,
12312        combined: Option<bool>,
12313        differ: Option<bool>,
12314        download: Option<bool>,
12315        dst_fs: &'a str,
12316        error: Option<bool>,
12317        match_: Option<bool>,
12318        missing_on_dst: Option<bool>,
12319        missing_on_src: Option<bool>,
12320        one_way: Option<bool>,
12321        src_fs: &'a str,
12322    ) -> Result<ResponseValue<types::OperationsCheckResponse>, Error<types::RcError>> {
12323        let url = format!("{}/operations/check", self.baseurl,);
12324        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12325        header_map.append(
12326            ::reqwest::header::HeaderName::from_static("api-version"),
12327            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12328        );
12329        #[allow(unused_mut)]
12330        let mut request = self
12331            .client
12332            .post(url)
12333            .header(
12334                ::reqwest::header::ACCEPT,
12335                ::reqwest::header::HeaderValue::from_static("application/json"),
12336            )
12337            .query(&progenitor_client::QueryParam::new("_async", &async_))
12338            .query(&progenitor_client::QueryParam::new("_group", &group))
12339            .query(&progenitor_client::QueryParam::new(
12340                "checkFileFs",
12341                &check_file_fs,
12342            ))
12343            .query(&progenitor_client::QueryParam::new(
12344                "checkFileHash",
12345                &check_file_hash,
12346            ))
12347            .query(&progenitor_client::QueryParam::new(
12348                "checkFileRemote",
12349                &check_file_remote,
12350            ))
12351            .query(&progenitor_client::QueryParam::new("combined", &combined))
12352            .query(&progenitor_client::QueryParam::new("differ", &differ))
12353            .query(&progenitor_client::QueryParam::new("download", &download))
12354            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12355            .query(&progenitor_client::QueryParam::new("error", &error))
12356            .query(&progenitor_client::QueryParam::new("match", &match_))
12357            .query(&progenitor_client::QueryParam::new(
12358                "missingOnDst",
12359                &missing_on_dst,
12360            ))
12361            .query(&progenitor_client::QueryParam::new(
12362                "missingOnSrc",
12363                &missing_on_src,
12364            ))
12365            .query(&progenitor_client::QueryParam::new("oneWay", &one_way))
12366            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12367            .headers(header_map)
12368            .build()?;
12369        let info = OperationInfo {
12370            operation_id: "operations_check",
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    ///Sync source to destination
12389    ///
12390    ///Synchronises a source remote to a destination remote, making the
12391    /// destination match the source.
12392    ///
12393    ///Sends a `POST` request to `/sync/sync`
12394    ///
12395    ///Arguments:
12396    /// - `async_`: Run the command asynchronously. Returns a job id
12397    ///   immediately.
12398    /// - `config`: JSON encoded config overrides applied for this call only.
12399    /// - `filter`: JSON encoded filter overrides applied for this call only.
12400    /// - `group`: Assign the request to a custom stats group.
12401    /// - `create_empty_src_dirs`: Set to true to create empty source
12402    ///   directories on the destination.
12403    /// - `dst_fs`: Destination remote path to sync to, e.g. `drive:dst`.
12404    /// - `src_fs`: Source remote path to sync from, e.g. `drive:src`.
12405    pub async fn sync_sync<'a>(
12406        &'a self,
12407        async_: Option<bool>,
12408        config: Option<&'a str>,
12409        filter: Option<&'a str>,
12410        group: Option<&'a str>,
12411        create_empty_src_dirs: Option<bool>,
12412        dst_fs: &'a str,
12413        src_fs: &'a str,
12414    ) -> Result<ResponseValue<types::SyncSyncResponse>, Error<types::RcError>> {
12415        let url = format!("{}/sync/sync", self.baseurl,);
12416        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12417        header_map.append(
12418            ::reqwest::header::HeaderName::from_static("api-version"),
12419            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12420        );
12421        #[allow(unused_mut)]
12422        let mut request = self
12423            .client
12424            .post(url)
12425            .header(
12426                ::reqwest::header::ACCEPT,
12427                ::reqwest::header::HeaderValue::from_static("application/json"),
12428            )
12429            .query(&progenitor_client::QueryParam::new("_async", &async_))
12430            .query(&progenitor_client::QueryParam::new("_config", &config))
12431            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12432            .query(&progenitor_client::QueryParam::new("_group", &group))
12433            .query(&progenitor_client::QueryParam::new(
12434                "createEmptySrcDirs",
12435                &create_empty_src_dirs,
12436            ))
12437            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12438            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12439            .headers(header_map)
12440            .build()?;
12441        let info = OperationInfo {
12442            operation_id: "sync_sync",
12443        };
12444        self.pre(&mut request, &info).await?;
12445        let result = self.exec(request, &info).await;
12446        self.post(&result, &info).await?;
12447        let response = result?;
12448        match response.status().as_u16() {
12449            200u16 => ResponseValue::from_response(response).await,
12450            400u16..=499u16 => Err(Error::ErrorResponse(
12451                ResponseValue::from_response(response).await?,
12452            )),
12453            500u16..=599u16 => Err(Error::ErrorResponse(
12454                ResponseValue::from_response(response).await?,
12455            )),
12456            _ => Err(Error::UnexpectedResponse(response)),
12457        }
12458    }
12459
12460    ///Copy source to destination
12461    ///
12462    ///Copies objects from a source remote to a destination remote without
12463    /// deleting destination files.
12464    ///
12465    ///Sends a `POST` request to `/sync/copy`
12466    ///
12467    ///Arguments:
12468    /// - `async_`: Run the command asynchronously. Returns a job id
12469    ///   immediately.
12470    /// - `config`: JSON encoded config overrides applied for this call only.
12471    /// - `filter`: JSON encoded filter overrides applied for this call only.
12472    /// - `group`: Assign the request to a custom stats group.
12473    /// - `create_empty_src_dirs`: Set to true to replicate empty source
12474    ///   directories on the destination.
12475    /// - `dst_fs`: Destination remote path to copy to.
12476    /// - `src_fs`: Source remote path to copy from.
12477    pub async fn sync_copy<'a>(
12478        &'a self,
12479        async_: Option<bool>,
12480        config: Option<&'a str>,
12481        filter: Option<&'a str>,
12482        group: Option<&'a str>,
12483        create_empty_src_dirs: Option<bool>,
12484        dst_fs: &'a str,
12485        src_fs: &'a str,
12486    ) -> Result<ResponseValue<types::SyncCopyResponse>, Error<types::RcError>> {
12487        let url = format!("{}/sync/copy", self.baseurl,);
12488        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12489        header_map.append(
12490            ::reqwest::header::HeaderName::from_static("api-version"),
12491            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12492        );
12493        #[allow(unused_mut)]
12494        let mut request = self
12495            .client
12496            .post(url)
12497            .header(
12498                ::reqwest::header::ACCEPT,
12499                ::reqwest::header::HeaderValue::from_static("application/json"),
12500            )
12501            .query(&progenitor_client::QueryParam::new("_async", &async_))
12502            .query(&progenitor_client::QueryParam::new("_config", &config))
12503            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12504            .query(&progenitor_client::QueryParam::new("_group", &group))
12505            .query(&progenitor_client::QueryParam::new(
12506                "createEmptySrcDirs",
12507                &create_empty_src_dirs,
12508            ))
12509            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12510            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12511            .headers(header_map)
12512            .build()?;
12513        let info = OperationInfo {
12514            operation_id: "sync_copy",
12515        };
12516        self.pre(&mut request, &info).await?;
12517        let result = self.exec(request, &info).await;
12518        self.post(&result, &info).await?;
12519        let response = result?;
12520        match response.status().as_u16() {
12521            200u16 => ResponseValue::from_response(response).await,
12522            400u16..=499u16 => Err(Error::ErrorResponse(
12523                ResponseValue::from_response(response).await?,
12524            )),
12525            500u16..=599u16 => Err(Error::ErrorResponse(
12526                ResponseValue::from_response(response).await?,
12527            )),
12528            _ => Err(Error::UnexpectedResponse(response)),
12529        }
12530    }
12531
12532    ///Move source to destination
12533    ///
12534    ///Moves objects from a source remote to a destination remote, optionally
12535    /// cleaning up empty directories.
12536    ///
12537    ///Sends a `POST` request to `/sync/move`
12538    ///
12539    ///Arguments:
12540    /// - `async_`: Run the command asynchronously. Returns a job id
12541    ///   immediately.
12542    /// - `config`: JSON encoded config overrides applied for this call only.
12543    /// - `filter`: JSON encoded filter overrides applied for this call only.
12544    /// - `group`: Assign the request to a custom stats group.
12545    /// - `create_empty_src_dirs`: Set to true to create empty source
12546    ///   directories on the destination.
12547    /// - `delete_empty_src_dirs`: Set to true to delete empty directories from
12548    ///   the source after the move completes.
12549    /// - `dst_fs`: Destination remote path that will receive moved files.
12550    /// - `src_fs`: Source remote path whose contents will be moved.
12551    pub async fn sync_move<'a>(
12552        &'a self,
12553        async_: Option<bool>,
12554        config: Option<&'a str>,
12555        filter: Option<&'a str>,
12556        group: Option<&'a str>,
12557        create_empty_src_dirs: Option<bool>,
12558        delete_empty_src_dirs: Option<bool>,
12559        dst_fs: &'a str,
12560        src_fs: &'a str,
12561    ) -> Result<ResponseValue<types::SyncMoveResponse>, Error<types::RcError>> {
12562        let url = format!("{}/sync/move", self.baseurl,);
12563        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12564        header_map.append(
12565            ::reqwest::header::HeaderName::from_static("api-version"),
12566            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12567        );
12568        #[allow(unused_mut)]
12569        let mut request = self
12570            .client
12571            .post(url)
12572            .header(
12573                ::reqwest::header::ACCEPT,
12574                ::reqwest::header::HeaderValue::from_static("application/json"),
12575            )
12576            .query(&progenitor_client::QueryParam::new("_async", &async_))
12577            .query(&progenitor_client::QueryParam::new("_config", &config))
12578            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12579            .query(&progenitor_client::QueryParam::new("_group", &group))
12580            .query(&progenitor_client::QueryParam::new(
12581                "createEmptySrcDirs",
12582                &create_empty_src_dirs,
12583            ))
12584            .query(&progenitor_client::QueryParam::new(
12585                "deleteEmptySrcDirs",
12586                &delete_empty_src_dirs,
12587            ))
12588            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
12589            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
12590            .headers(header_map)
12591            .build()?;
12592        let info = OperationInfo {
12593            operation_id: "sync_move",
12594        };
12595        self.pre(&mut request, &info).await?;
12596        let result = self.exec(request, &info).await;
12597        self.post(&result, &info).await?;
12598        let response = result?;
12599        match response.status().as_u16() {
12600            200u16 => ResponseValue::from_response(response).await,
12601            400u16..=499u16 => Err(Error::ErrorResponse(
12602                ResponseValue::from_response(response).await?,
12603            )),
12604            500u16..=599u16 => Err(Error::ErrorResponse(
12605                ResponseValue::from_response(response).await?,
12606            )),
12607            _ => Err(Error::UnexpectedResponse(response)),
12608        }
12609    }
12610
12611    ///Bidirectional sync
12612    ///
12613    ///Performs a bidirectional synchronisation between two paths, supporting
12614    /// safety checks and recovery options.
12615    ///
12616    ///Sends a `POST` request to `/sync/bisync`
12617    ///
12618    ///Arguments:
12619    /// - `async_`: Run the command asynchronously. Returns a job id
12620    ///   immediately.
12621    /// - `config`: JSON encoded config overrides applied for this call only.
12622    /// - `filter`: JSON encoded filter overrides applied for this call only.
12623    /// - `group`: Assign the request to a custom stats group.
12624    /// - `backupdir1`: Backup directory on the first remote for changed files.
12625    /// - `backupdir2`: Backup directory on the second remote for changed files.
12626    /// - `check_access`: Set to true to abort if `RCLONE_TEST` files are
12627    ///   missing on either side.
12628    /// - `check_filename`: Override the access-check sentinel filename;
12629    ///   defaults to `RCLONE_TEST`.
12630    /// - `check_sync`: Controls final listing comparison; leave true for normal
12631    ///   verification or set false to skip.
12632    /// - `create_empty_src_dirs`: Set to true to mirror empty directories
12633    ///   between the two paths.
12634    /// - `dry_run`: Set to true to simulate the bisync run without making
12635    ///   changes.
12636    /// - `filters_file`: Path to an rclone filters file applied to both paths.
12637    /// - `force`: Set to true to bypass the `maxDelete` safety check.
12638    /// - `ignore_listing_checksum`: Set to true to ignore checksum differences
12639    ///   when comparing listings.
12640    /// - `max_delete`: Abort the run if deletions exceed this percentage
12641    ///   (default 50).
12642    /// - `no_cleanup`: Set to true to keep bisync working files after
12643    ///   completion.
12644    /// - `path1`: First remote directory, e.g. `drive:path1`.
12645    /// - `path2`: Second remote directory, e.g. `drive:path2`.
12646    /// - `remove_empty_dirs`: Set to true to remove empty directories during
12647    ///   cleanup.
12648    /// - `resilient`: Set to true to allow retrying after certain recoverable
12649    ///   errors.
12650    /// - `resync`: Set to true to perform a one-time resync, rebuilding bisync
12651    ///   history.
12652    /// - `workdir`: Directory path used to store bisync working files.
12653    pub async fn sync_bisync<'a>(
12654        &'a self,
12655        async_: Option<bool>,
12656        config: Option<&'a str>,
12657        filter: Option<&'a str>,
12658        group: Option<&'a str>,
12659        backupdir1: Option<&'a str>,
12660        backupdir2: Option<&'a str>,
12661        check_access: Option<bool>,
12662        check_filename: Option<&'a str>,
12663        check_sync: Option<bool>,
12664        create_empty_src_dirs: Option<bool>,
12665        dry_run: Option<bool>,
12666        filters_file: Option<&'a str>,
12667        force: Option<bool>,
12668        ignore_listing_checksum: Option<bool>,
12669        max_delete: Option<f64>,
12670        no_cleanup: Option<bool>,
12671        path1: &'a str,
12672        path2: &'a str,
12673        remove_empty_dirs: Option<bool>,
12674        resilient: Option<bool>,
12675        resync: Option<bool>,
12676        workdir: Option<&'a str>,
12677    ) -> Result<ResponseValue<types::SyncBisyncResponse>, Error<types::RcError>> {
12678        let url = format!("{}/sync/bisync", self.baseurl,);
12679        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12680        header_map.append(
12681            ::reqwest::header::HeaderName::from_static("api-version"),
12682            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12683        );
12684        #[allow(unused_mut)]
12685        let mut request = self
12686            .client
12687            .post(url)
12688            .header(
12689                ::reqwest::header::ACCEPT,
12690                ::reqwest::header::HeaderValue::from_static("application/json"),
12691            )
12692            .query(&progenitor_client::QueryParam::new("_async", &async_))
12693            .query(&progenitor_client::QueryParam::new("_config", &config))
12694            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12695            .query(&progenitor_client::QueryParam::new("_group", &group))
12696            .query(&progenitor_client::QueryParam::new(
12697                "backupdir1",
12698                &backupdir1,
12699            ))
12700            .query(&progenitor_client::QueryParam::new(
12701                "backupdir2",
12702                &backupdir2,
12703            ))
12704            .query(&progenitor_client::QueryParam::new(
12705                "checkAccess",
12706                &check_access,
12707            ))
12708            .query(&progenitor_client::QueryParam::new(
12709                "checkFilename",
12710                &check_filename,
12711            ))
12712            .query(&progenitor_client::QueryParam::new(
12713                "checkSync",
12714                &check_sync,
12715            ))
12716            .query(&progenitor_client::QueryParam::new(
12717                "createEmptySrcDirs",
12718                &create_empty_src_dirs,
12719            ))
12720            .query(&progenitor_client::QueryParam::new("dryRun", &dry_run))
12721            .query(&progenitor_client::QueryParam::new(
12722                "filtersFile",
12723                &filters_file,
12724            ))
12725            .query(&progenitor_client::QueryParam::new("force", &force))
12726            .query(&progenitor_client::QueryParam::new(
12727                "ignoreListingChecksum",
12728                &ignore_listing_checksum,
12729            ))
12730            .query(&progenitor_client::QueryParam::new(
12731                "maxDelete",
12732                &max_delete,
12733            ))
12734            .query(&progenitor_client::QueryParam::new(
12735                "noCleanup",
12736                &no_cleanup,
12737            ))
12738            .query(&progenitor_client::QueryParam::new("path1", &path1))
12739            .query(&progenitor_client::QueryParam::new("path2", &path2))
12740            .query(&progenitor_client::QueryParam::new(
12741                "removeEmptyDirs",
12742                &remove_empty_dirs,
12743            ))
12744            .query(&progenitor_client::QueryParam::new("resilient", &resilient))
12745            .query(&progenitor_client::QueryParam::new("resync", &resync))
12746            .query(&progenitor_client::QueryParam::new("workdir", &workdir))
12747            .headers(header_map)
12748            .build()?;
12749        let info = OperationInfo {
12750            operation_id: "sync_bisync",
12751        };
12752        self.pre(&mut request, &info).await?;
12753        let result = self.exec(request, &info).await;
12754        self.post(&result, &info).await?;
12755        let response = result?;
12756        match response.status().as_u16() {
12757            200u16 => ResponseValue::from_response(response).await,
12758            400u16..=499u16 => Err(Error::ErrorResponse(
12759                ResponseValue::from_response(response).await?,
12760            )),
12761            500u16..=599u16 => Err(Error::ErrorResponse(
12762                ResponseValue::from_response(response).await?,
12763            )),
12764            _ => Err(Error::UnexpectedResponse(response)),
12765        }
12766    }
12767
12768    ///List option blocks
12769    ///
12770    ///Returns the names of option blocks that can be queried or updated.
12771    ///
12772    ///Sends a `POST` request to `/options/blocks`
12773    ///
12774    ///Arguments:
12775    /// - `async_`: Run the command asynchronously. Returns a job id
12776    ///   immediately.
12777    /// - `group`: Assign the request to a custom stats group.
12778    pub async fn options_blocks<'a>(
12779        &'a self,
12780        async_: Option<bool>,
12781        group: Option<&'a str>,
12782    ) -> Result<ResponseValue<types::OptionsBlocksResponse>, Error<types::RcError>> {
12783        let url = format!("{}/options/blocks", self.baseurl,);
12784        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12785        header_map.append(
12786            ::reqwest::header::HeaderName::from_static("api-version"),
12787            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12788        );
12789        #[allow(unused_mut)]
12790        let mut request = self
12791            .client
12792            .post(url)
12793            .header(
12794                ::reqwest::header::ACCEPT,
12795                ::reqwest::header::HeaderValue::from_static("application/json"),
12796            )
12797            .query(&progenitor_client::QueryParam::new("_async", &async_))
12798            .query(&progenitor_client::QueryParam::new("_group", &group))
12799            .headers(header_map)
12800            .build()?;
12801        let info = OperationInfo {
12802            operation_id: "options_blocks",
12803        };
12804        self.pre(&mut request, &info).await?;
12805        let result = self.exec(request, &info).await;
12806        self.post(&result, &info).await?;
12807        let response = result?;
12808        match response.status().as_u16() {
12809            200u16 => ResponseValue::from_response(response).await,
12810            400u16..=499u16 => Err(Error::ErrorResponse(
12811                ResponseValue::from_response(response).await?,
12812            )),
12813            500u16..=599u16 => Err(Error::ErrorResponse(
12814                ResponseValue::from_response(response).await?,
12815            )),
12816            _ => Err(Error::UnexpectedResponse(response)),
12817        }
12818    }
12819
12820    ///Get option values
12821    ///
12822    ///Returns the current global option values, optionally filtered by block.
12823    ///
12824    ///Sends a `POST` request to `/options/get`
12825    ///
12826    ///Arguments:
12827    /// - `async_`: Run the command asynchronously. Returns a job id
12828    ///   immediately.
12829    /// - `group`: Assign the request to a custom stats group.
12830    /// - `blocks`: Optional comma-separated list of option block names to
12831    ///   return.
12832    pub async fn options_get<'a>(
12833        &'a self,
12834        async_: Option<bool>,
12835        group: Option<&'a str>,
12836        blocks: Option<&'a str>,
12837    ) -> Result<ResponseValue<types::OptionsGetResponse>, Error<types::RcError>> {
12838        let url = format!("{}/options/get", self.baseurl,);
12839        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12840        header_map.append(
12841            ::reqwest::header::HeaderName::from_static("api-version"),
12842            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12843        );
12844        #[allow(unused_mut)]
12845        let mut request = self
12846            .client
12847            .post(url)
12848            .header(
12849                ::reqwest::header::ACCEPT,
12850                ::reqwest::header::HeaderValue::from_static("application/json"),
12851            )
12852            .query(&progenitor_client::QueryParam::new("_async", &async_))
12853            .query(&progenitor_client::QueryParam::new("_group", &group))
12854            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12855            .headers(header_map)
12856            .build()?;
12857        let info = OperationInfo {
12858            operation_id: "options_get",
12859        };
12860        self.pre(&mut request, &info).await?;
12861        let result = self.exec(request, &info).await;
12862        self.post(&result, &info).await?;
12863        let response = result?;
12864        match response.status().as_u16() {
12865            200u16 => ResponseValue::from_response(response).await,
12866            400u16..=499u16 => Err(Error::ErrorResponse(
12867                ResponseValue::from_response(response).await?,
12868            )),
12869            500u16..=599u16 => Err(Error::ErrorResponse(
12870                ResponseValue::from_response(response).await?,
12871            )),
12872            _ => Err(Error::UnexpectedResponse(response)),
12873        }
12874    }
12875
12876    ///Describe options
12877    ///
12878    ///Returns metadata for options, including help text and defaults, grouped
12879    /// by block.
12880    ///
12881    ///Sends a `POST` request to `/options/info`
12882    ///
12883    ///Arguments:
12884    /// - `async_`: Run the command asynchronously. Returns a job id
12885    ///   immediately.
12886    /// - `group`: Assign the request to a custom stats group.
12887    /// - `blocks`: Optional comma-separated list of option block names to
12888    ///   describe.
12889    pub async fn options_info<'a>(
12890        &'a self,
12891        async_: Option<bool>,
12892        group: Option<&'a str>,
12893        blocks: Option<&'a str>,
12894    ) -> Result<ResponseValue<types::OptionsInfoResponse>, Error<types::RcError>> {
12895        let url = format!("{}/options/info", self.baseurl,);
12896        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12897        header_map.append(
12898            ::reqwest::header::HeaderName::from_static("api-version"),
12899            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12900        );
12901        #[allow(unused_mut)]
12902        let mut request = self
12903            .client
12904            .post(url)
12905            .header(
12906                ::reqwest::header::ACCEPT,
12907                ::reqwest::header::HeaderValue::from_static("application/json"),
12908            )
12909            .query(&progenitor_client::QueryParam::new("_async", &async_))
12910            .query(&progenitor_client::QueryParam::new("_group", &group))
12911            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12912            .headers(header_map)
12913            .build()?;
12914        let info = OperationInfo {
12915            operation_id: "options_info",
12916        };
12917        self.pre(&mut request, &info).await?;
12918        let result = self.exec(request, &info).await;
12919        self.post(&result, &info).await?;
12920        let response = result?;
12921        match response.status().as_u16() {
12922            200u16 => ResponseValue::from_response(response).await,
12923            400u16..=499u16 => Err(Error::ErrorResponse(
12924                ResponseValue::from_response(response).await?,
12925            )),
12926            500u16..=599u16 => Err(Error::ErrorResponse(
12927                ResponseValue::from_response(response).await?,
12928            )),
12929            _ => Err(Error::UnexpectedResponse(response)),
12930        }
12931    }
12932
12933    ///Set option values
12934    ///
12935    ///Sets temporary option overrides for the running process by supplying
12936    /// key/value pairs grouped under option block names. Provide one or more
12937    /// query parameters whose names match the blocks you want to modify (for
12938    /// example `main`, `rc`, `http`). Each block parameter carries an object of
12939    /// option overrides.
12940    ///
12941    ///
12942    ///Sends a `POST` request to `/options/set`
12943    ///
12944    ///Arguments:
12945    /// - `async_`: Run the command asynchronously. Returns a job id
12946    ///   immediately.
12947    /// - `group`: Assign the request to a custom stats group.
12948    /// - `dlna`: Overrides for the `dlna` option block.
12949    /// - `filter`: Overrides for the `filter` option block.
12950    /// - `ftp`: Overrides for the `ftp` option block.
12951    /// - `http`: Overrides for the `http` option block.
12952    /// - `log`: Overrides for the `log` option block.
12953    /// - `main`: Overrides for the `main` option block.
12954    /// - `mount`: Overrides for the `mount` option block.
12955    /// - `nfs`: Overrides for the `nfs` option block.
12956    /// - `proxy`: Overrides for the `proxy` option block.
12957    /// - `rc`: Overrides for the `rc` option block.
12958    /// - `restic`: Overrides for the `restic` option block.
12959    /// - `s3`: Overrides for the `s3` option block.
12960    /// - `sftp`: Overrides for the `sftp` option block.
12961    /// - `vfs`: Overrides for the `vfs` option block.
12962    /// - `webdav`: Overrides for the `webdav` option block.
12963    pub async fn options_set<'a>(
12964        &'a self,
12965        async_: Option<bool>,
12966        group: Option<&'a str>,
12967        dlna: Option<
12968            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetDlnaValue>,
12969        >,
12970        filter: Option<
12971            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFilterValue>,
12972        >,
12973        ftp: Option<
12974            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFtpValue>,
12975        >,
12976        http: Option<
12977            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetHttpValue>,
12978        >,
12979        log: Option<
12980            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetLogValue>,
12981        >,
12982        main: Option<
12983            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMainValue>,
12984        >,
12985        mount: Option<
12986            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMountValue>,
12987        >,
12988        nfs: Option<
12989            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetNfsValue>,
12990        >,
12991        proxy: Option<
12992            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetProxyValue>,
12993        >,
12994        rc: Option<
12995            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetRcValue>,
12996        >,
12997        restic: Option<
12998            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetResticValue>,
12999        >,
13000        s3: Option<
13001            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetS3Value>,
13002        >,
13003        sftp: Option<
13004            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetSftpValue>,
13005        >,
13006        vfs: Option<
13007            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetVfsValue>,
13008        >,
13009        webdav: Option<
13010            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetWebdavValue>,
13011        >,
13012    ) -> Result<
13013        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13014        Error<types::RcError>,
13015    > {
13016        let url = format!("{}/options/set", self.baseurl,);
13017        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13018        header_map.append(
13019            ::reqwest::header::HeaderName::from_static("api-version"),
13020            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13021        );
13022        #[allow(unused_mut)]
13023        let mut request = self
13024            .client
13025            .post(url)
13026            .header(
13027                ::reqwest::header::ACCEPT,
13028                ::reqwest::header::HeaderValue::from_static("application/json"),
13029            )
13030            .query(&progenitor_client::QueryParam::new("_async", &async_))
13031            .query(&progenitor_client::QueryParam::new("_group", &group))
13032            .query(&progenitor_client::QueryParam::new("dlna", &dlna))
13033            .query(&progenitor_client::QueryParam::new("filter", &filter))
13034            .query(&progenitor_client::QueryParam::new("ftp", &ftp))
13035            .query(&progenitor_client::QueryParam::new("http", &http))
13036            .query(&progenitor_client::QueryParam::new("log", &log))
13037            .query(&progenitor_client::QueryParam::new("main", &main))
13038            .query(&progenitor_client::QueryParam::new("mount", &mount))
13039            .query(&progenitor_client::QueryParam::new("nfs", &nfs))
13040            .query(&progenitor_client::QueryParam::new("proxy", &proxy))
13041            .query(&progenitor_client::QueryParam::new("rc", &rc))
13042            .query(&progenitor_client::QueryParam::new("restic", &restic))
13043            .query(&progenitor_client::QueryParam::new("s3", &s3))
13044            .query(&progenitor_client::QueryParam::new("sftp", &sftp))
13045            .query(&progenitor_client::QueryParam::new("vfs", &vfs))
13046            .query(&progenitor_client::QueryParam::new("webdav", &webdav))
13047            .headers(header_map)
13048            .build()?;
13049        let info = OperationInfo {
13050            operation_id: "options_set",
13051        };
13052        self.pre(&mut request, &info).await?;
13053        let result = self.exec(request, &info).await;
13054        self.post(&result, &info).await?;
13055        let response = result?;
13056        match response.status().as_u16() {
13057            200u16 => ResponseValue::from_response(response).await,
13058            400u16..=499u16 => Err(Error::ErrorResponse(
13059                ResponseValue::from_response(response).await?,
13060            )),
13061            500u16..=599u16 => Err(Error::ErrorResponse(
13062                ResponseValue::from_response(response).await?,
13063            )),
13064            _ => Err(Error::UnexpectedResponse(response)),
13065        }
13066    }
13067
13068    ///Show effective options
13069    ///
13070    ///Returns the current effective options for this request, including
13071    /// `_config` and `_filter` overrides.
13072    ///
13073    ///Sends a `POST` request to `/options/local`
13074    ///
13075    ///Arguments:
13076    /// - `async_`: Run the command asynchronously. Returns a job id
13077    ///   immediately.
13078    /// - `group`: Assign the request to a custom stats group.
13079    pub async fn options_local<'a>(
13080        &'a self,
13081        async_: Option<bool>,
13082        group: Option<&'a str>,
13083    ) -> Result<ResponseValue<types::OptionsLocalResponse>, Error<types::RcError>> {
13084        let url = format!("{}/options/local", self.baseurl,);
13085        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13086        header_map.append(
13087            ::reqwest::header::HeaderName::from_static("api-version"),
13088            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13089        );
13090        #[allow(unused_mut)]
13091        let mut request = self
13092            .client
13093            .post(url)
13094            .header(
13095                ::reqwest::header::ACCEPT,
13096                ::reqwest::header::HeaderValue::from_static("application/json"),
13097            )
13098            .query(&progenitor_client::QueryParam::new("_async", &async_))
13099            .query(&progenitor_client::QueryParam::new("_group", &group))
13100            .headers(header_map)
13101            .build()?;
13102        let info = OperationInfo {
13103            operation_id: "options_local",
13104        };
13105        self.pre(&mut request, &info).await?;
13106        let result = self.exec(request, &info).await;
13107        self.post(&result, &info).await?;
13108        let response = result?;
13109        match response.status().as_u16() {
13110            200u16 => ResponseValue::from_response(response).await,
13111            400u16..=499u16 => Err(Error::ErrorResponse(
13112                ResponseValue::from_response(response).await?,
13113            )),
13114            500u16..=599u16 => Err(Error::ErrorResponse(
13115                ResponseValue::from_response(response).await?,
13116            )),
13117            _ => Err(Error::UnexpectedResponse(response)),
13118        }
13119    }
13120
13121    ///List serve instances
13122    ///
13123    ///Returns all running `rclone serve` instances with their IDs and options.
13124    ///
13125    ///Sends a `POST` request to `/serve/list`
13126    ///
13127    ///Arguments:
13128    /// - `async_`: Run the command asynchronously. Returns a job id
13129    ///   immediately.
13130    /// - `group`: Assign the request to a custom stats group.
13131    pub async fn serve_list<'a>(
13132        &'a self,
13133        async_: Option<bool>,
13134        group: Option<&'a str>,
13135    ) -> Result<ResponseValue<types::ServeListResponse>, Error<types::RcError>> {
13136        let url = format!("{}/serve/list", self.baseurl,);
13137        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13138        header_map.append(
13139            ::reqwest::header::HeaderName::from_static("api-version"),
13140            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13141        );
13142        #[allow(unused_mut)]
13143        let mut request = self
13144            .client
13145            .post(url)
13146            .header(
13147                ::reqwest::header::ACCEPT,
13148                ::reqwest::header::HeaderValue::from_static("application/json"),
13149            )
13150            .query(&progenitor_client::QueryParam::new("_async", &async_))
13151            .query(&progenitor_client::QueryParam::new("_group", &group))
13152            .headers(header_map)
13153            .build()?;
13154        let info = OperationInfo {
13155            operation_id: "serve_list",
13156        };
13157        self.pre(&mut request, &info).await?;
13158        let result = self.exec(request, &info).await;
13159        self.post(&result, &info).await?;
13160        let response = result?;
13161        match response.status().as_u16() {
13162            200u16 => ResponseValue::from_response(response).await,
13163            400u16..=499u16 => Err(Error::ErrorResponse(
13164                ResponseValue::from_response(response).await?,
13165            )),
13166            500u16..=599u16 => Err(Error::ErrorResponse(
13167                ResponseValue::from_response(response).await?,
13168            )),
13169            _ => Err(Error::UnexpectedResponse(response)),
13170        }
13171    }
13172
13173    ///Start serve instance
13174    ///
13175    ///Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with
13176    /// the provided parameters.
13177    ///
13178    ///Sends a `POST` request to `/serve/start`
13179    ///
13180    ///Arguments:
13181    /// - `async_`: Run the command asynchronously. Returns a job id
13182    ///   immediately.
13183    /// - `config`: JSON encoded config overrides applied for this call only.
13184    /// - `filter`: JSON encoded filter overrides applied for this call only.
13185    /// - `group`: Assign the request to a custom stats group.
13186    /// - `addr`: Address and port to bind the server to, such as `:5572` or
13187    ///   `localhost:8080`.
13188    /// - `fs`: Remote path that will be served.
13189    /// - `params`: Additional arbitrary parameters allowed.
13190    /// - `type_`: Type of server to start (e.g. `http`, `webdav`, `ftp`,
13191    ///   `sftp`).
13192    pub async fn serve_start<'a>(
13193        &'a self,
13194        async_: Option<bool>,
13195        config: Option<&'a str>,
13196        filter: Option<&'a str>,
13197        group: Option<&'a str>,
13198        addr: &'a str,
13199        fs: &'a str,
13200        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13201        type_: &'a str,
13202    ) -> Result<ResponseValue<types::ServeStartResponse>, Error<types::RcError>> {
13203        let url = format!("{}/serve/start", self.baseurl,);
13204        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13205        header_map.append(
13206            ::reqwest::header::HeaderName::from_static("api-version"),
13207            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13208        );
13209        #[allow(unused_mut)]
13210        let mut request = self
13211            .client
13212            .post(url)
13213            .header(
13214                ::reqwest::header::ACCEPT,
13215                ::reqwest::header::HeaderValue::from_static("application/json"),
13216            )
13217            .query(&progenitor_client::QueryParam::new("_async", &async_))
13218            .query(&progenitor_client::QueryParam::new("_config", &config))
13219            .query(&progenitor_client::QueryParam::new("_filter", &filter))
13220            .query(&progenitor_client::QueryParam::new("_group", &group))
13221            .query(&progenitor_client::QueryParam::new("addr", &addr))
13222            .query(&progenitor_client::QueryParam::new("fs", &fs))
13223            .query(&progenitor_client::QueryParam::new("params", &params))
13224            .query(&progenitor_client::QueryParam::new("type", &type_))
13225            .headers(header_map)
13226            .build()?;
13227        let info = OperationInfo {
13228            operation_id: "serve_start",
13229        };
13230        self.pre(&mut request, &info).await?;
13231        let result = self.exec(request, &info).await;
13232        self.post(&result, &info).await?;
13233        let response = result?;
13234        match response.status().as_u16() {
13235            200u16 => ResponseValue::from_response(response).await,
13236            400u16..=499u16 => Err(Error::ErrorResponse(
13237                ResponseValue::from_response(response).await?,
13238            )),
13239            500u16..=599u16 => Err(Error::ErrorResponse(
13240                ResponseValue::from_response(response).await?,
13241            )),
13242            _ => Err(Error::UnexpectedResponse(response)),
13243        }
13244    }
13245
13246    ///Stop serve instance
13247    ///
13248    ///Stops a running `serve` instance identified by its ID.
13249    ///
13250    ///Sends a `POST` request to `/serve/stop`
13251    ///
13252    ///Arguments:
13253    /// - `async_`: Run the command asynchronously. Returns a job id
13254    ///   immediately.
13255    /// - `group`: Assign the request to a custom stats group.
13256    /// - `id`: Identifier of the running serve instance returned by
13257    ///   `serve/start`.
13258    pub async fn serve_stop<'a>(
13259        &'a self,
13260        async_: Option<bool>,
13261        group: Option<&'a str>,
13262        id: &'a str,
13263    ) -> Result<
13264        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13265        Error<types::RcError>,
13266    > {
13267        let url = format!("{}/serve/stop", self.baseurl,);
13268        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13269        header_map.append(
13270            ::reqwest::header::HeaderName::from_static("api-version"),
13271            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13272        );
13273        #[allow(unused_mut)]
13274        let mut request = self
13275            .client
13276            .post(url)
13277            .header(
13278                ::reqwest::header::ACCEPT,
13279                ::reqwest::header::HeaderValue::from_static("application/json"),
13280            )
13281            .query(&progenitor_client::QueryParam::new("_async", &async_))
13282            .query(&progenitor_client::QueryParam::new("_group", &group))
13283            .query(&progenitor_client::QueryParam::new("id", &id))
13284            .headers(header_map)
13285            .build()?;
13286        let info = OperationInfo {
13287            operation_id: "serve_stop",
13288        };
13289        self.pre(&mut request, &info).await?;
13290        let result = self.exec(request, &info).await;
13291        self.post(&result, &info).await?;
13292        let response = result?;
13293        match response.status().as_u16() {
13294            200u16 => ResponseValue::from_response(response).await,
13295            400u16..=499u16 => Err(Error::ErrorResponse(
13296                ResponseValue::from_response(response).await?,
13297            )),
13298            500u16..=599u16 => Err(Error::ErrorResponse(
13299                ResponseValue::from_response(response).await?,
13300            )),
13301            _ => Err(Error::UnexpectedResponse(response)),
13302        }
13303    }
13304
13305    ///Stop all serve instances
13306    ///
13307    ///Stops every active `serve` instance.
13308    ///
13309    ///Sends a `POST` request to `/serve/stopall`
13310    ///
13311    ///Arguments:
13312    /// - `async_`: Run the command asynchronously. Returns a job id
13313    ///   immediately.
13314    /// - `group`: Assign the request to a custom stats group.
13315    pub async fn serve_stopall<'a>(
13316        &'a self,
13317        async_: Option<bool>,
13318        group: Option<&'a str>,
13319    ) -> Result<
13320        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13321        Error<types::RcError>,
13322    > {
13323        let url = format!("{}/serve/stopall", self.baseurl,);
13324        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13325        header_map.append(
13326            ::reqwest::header::HeaderName::from_static("api-version"),
13327            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13328        );
13329        #[allow(unused_mut)]
13330        let mut request = self
13331            .client
13332            .post(url)
13333            .header(
13334                ::reqwest::header::ACCEPT,
13335                ::reqwest::header::HeaderValue::from_static("application/json"),
13336            )
13337            .query(&progenitor_client::QueryParam::new("_async", &async_))
13338            .query(&progenitor_client::QueryParam::new("_group", &group))
13339            .headers(header_map)
13340            .build()?;
13341        let info = OperationInfo {
13342            operation_id: "serve_stopall",
13343        };
13344        self.pre(&mut request, &info).await?;
13345        let result = self.exec(request, &info).await;
13346        self.post(&result, &info).await?;
13347        let response = result?;
13348        match response.status().as_u16() {
13349            200u16 => ResponseValue::from_response(response).await,
13350            400u16..=499u16 => Err(Error::ErrorResponse(
13351                ResponseValue::from_response(response).await?,
13352            )),
13353            500u16..=599u16 => Err(Error::ErrorResponse(
13354                ResponseValue::from_response(response).await?,
13355            )),
13356            _ => Err(Error::UnexpectedResponse(response)),
13357        }
13358    }
13359
13360    ///List serve types
13361    ///
13362    ///Returns the list of supported `rclone serve` protocols.
13363    ///
13364    ///Sends a `POST` request to `/serve/types`
13365    ///
13366    ///Arguments:
13367    /// - `async_`: Run the command asynchronously. Returns a job id
13368    ///   immediately.
13369    /// - `group`: Assign the request to a custom stats group.
13370    pub async fn serve_types<'a>(
13371        &'a self,
13372        async_: Option<bool>,
13373        group: Option<&'a str>,
13374    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
13375        let url = format!("{}/serve/types", self.baseurl,);
13376        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13377        header_map.append(
13378            ::reqwest::header::HeaderName::from_static("api-version"),
13379            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13380        );
13381        #[allow(unused_mut)]
13382        let mut request = self
13383            .client
13384            .post(url)
13385            .header(
13386                ::reqwest::header::ACCEPT,
13387                ::reqwest::header::HeaderValue::from_static("application/json"),
13388            )
13389            .query(&progenitor_client::QueryParam::new("_async", &async_))
13390            .query(&progenitor_client::QueryParam::new("_group", &group))
13391            .headers(header_map)
13392            .build()?;
13393        let info = OperationInfo {
13394            operation_id: "serve_types",
13395        };
13396        self.pre(&mut request, &info).await?;
13397        let result = self.exec(request, &info).await;
13398        self.post(&result, &info).await?;
13399        let response = result?;
13400        match response.status().as_u16() {
13401            200u16 => Ok(ResponseValue::empty(response)),
13402            400u16..=499u16 => Err(Error::ErrorResponse(
13403                ResponseValue::from_response(response).await?,
13404            )),
13405            500u16..=599u16 => Err(Error::ErrorResponse(
13406                ResponseValue::from_response(response).await?,
13407            )),
13408            _ => Err(Error::UnexpectedResponse(response)),
13409        }
13410    }
13411
13412    ///Forget cached paths
13413    ///
13414    ///Evicts specific files or directories from the VFS directory cache.
13415    ///
13416    ///Sends a `POST` request to `/vfs/forget`
13417    ///
13418    ///Arguments:
13419    /// - `async_`: Run the command asynchronously. Returns a job id
13420    ///   immediately.
13421    /// - `group`: Assign the request to a custom stats group.
13422    /// - `fs`: Optional VFS identifier to target; required when more than one
13423    ///   VFS is active.
13424    /// - `params`: Additional arbitrary parameters allowed.
13425    pub async fn vfs_forget<'a>(
13426        &'a self,
13427        async_: Option<bool>,
13428        group: Option<&'a str>,
13429        fs: Option<&'a str>,
13430        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13431    ) -> Result<ResponseValue<types::VfsForgetResponse>, Error<types::RcError>> {
13432        let url = format!("{}/vfs/forget", self.baseurl,);
13433        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13434        header_map.append(
13435            ::reqwest::header::HeaderName::from_static("api-version"),
13436            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13437        );
13438        #[allow(unused_mut)]
13439        let mut request = self
13440            .client
13441            .post(url)
13442            .header(
13443                ::reqwest::header::ACCEPT,
13444                ::reqwest::header::HeaderValue::from_static("application/json"),
13445            )
13446            .query(&progenitor_client::QueryParam::new("_async", &async_))
13447            .query(&progenitor_client::QueryParam::new("_group", &group))
13448            .query(&progenitor_client::QueryParam::new("fs", &fs))
13449            .query(&progenitor_client::QueryParam::new("params", &params))
13450            .headers(header_map)
13451            .build()?;
13452        let info = OperationInfo {
13453            operation_id: "vfs_forget",
13454        };
13455        self.pre(&mut request, &info).await?;
13456        let result = self.exec(request, &info).await;
13457        self.post(&result, &info).await?;
13458        let response = result?;
13459        match response.status().as_u16() {
13460            200u16 => ResponseValue::from_response(response).await,
13461            400u16..=499u16 => Err(Error::ErrorResponse(
13462                ResponseValue::from_response(response).await?,
13463            )),
13464            500u16..=599u16 => Err(Error::ErrorResponse(
13465                ResponseValue::from_response(response).await?,
13466            )),
13467            _ => Err(Error::UnexpectedResponse(response)),
13468        }
13469    }
13470
13471    ///List VFS instances
13472    ///
13473    ///Lists the active VFS instances and their identifiers.
13474    ///
13475    ///Sends a `POST` request to `/vfs/list`
13476    ///
13477    ///Arguments:
13478    /// - `async_`: Run the command asynchronously. Returns a job id
13479    ///   immediately.
13480    /// - `group`: Assign the request to a custom stats group.
13481    /// - `fs`: Optional VFS identifier; omit to list all active VFS instances.
13482    pub async fn vfs_list<'a>(
13483        &'a self,
13484        async_: Option<bool>,
13485        group: Option<&'a str>,
13486        fs: Option<&'a str>,
13487    ) -> Result<ResponseValue<types::VfsListResponse>, Error<types::RcError>> {
13488        let url = format!("{}/vfs/list", self.baseurl,);
13489        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13490        header_map.append(
13491            ::reqwest::header::HeaderName::from_static("api-version"),
13492            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13493        );
13494        #[allow(unused_mut)]
13495        let mut request = self
13496            .client
13497            .post(url)
13498            .header(
13499                ::reqwest::header::ACCEPT,
13500                ::reqwest::header::HeaderValue::from_static("application/json"),
13501            )
13502            .query(&progenitor_client::QueryParam::new("_async", &async_))
13503            .query(&progenitor_client::QueryParam::new("_group", &group))
13504            .query(&progenitor_client::QueryParam::new("fs", &fs))
13505            .headers(header_map)
13506            .build()?;
13507        let info = OperationInfo {
13508            operation_id: "vfs_list",
13509        };
13510        self.pre(&mut request, &info).await?;
13511        let result = self.exec(request, &info).await;
13512        self.post(&result, &info).await?;
13513        let response = result?;
13514        match response.status().as_u16() {
13515            200u16 => ResponseValue::from_response(response).await,
13516            400u16..=499u16 => Err(Error::ErrorResponse(
13517                ResponseValue::from_response(response).await?,
13518            )),
13519            500u16..=599u16 => Err(Error::ErrorResponse(
13520                ResponseValue::from_response(response).await?,
13521            )),
13522            _ => Err(Error::UnexpectedResponse(response)),
13523        }
13524    }
13525
13526    ///Get or set poll interval
13527    ///
13528    ///Reads or updates the VFS poll interval duration, optionally waiting for
13529    /// the change to apply.
13530    ///
13531    ///Sends a `POST` request to `/vfs/poll-interval`
13532    ///
13533    ///Arguments:
13534    /// - `async_`: Run the command asynchronously. Returns a job id
13535    ///   immediately.
13536    /// - `group`: Assign the request to a custom stats group.
13537    /// - `fs`: Optional VFS identifier whose poll interval should be queried or
13538    ///   modified.
13539    /// - `interval`: Duration string (e.g. `5m`) to set as the new poll
13540    ///   interval.
13541    /// - `timeout`: Duration to wait for the poll interval change to take
13542    ///   effect; `0` waits indefinitely.
13543    pub async fn vfs_poll_interval<'a>(
13544        &'a self,
13545        async_: Option<bool>,
13546        group: Option<&'a str>,
13547        fs: Option<&'a str>,
13548        interval: Option<&'a str>,
13549        timeout: Option<&'a str>,
13550    ) -> Result<
13551        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13552        Error<types::RcError>,
13553    > {
13554        let url = format!("{}/vfs/poll-interval", self.baseurl,);
13555        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13556        header_map.append(
13557            ::reqwest::header::HeaderName::from_static("api-version"),
13558            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13559        );
13560        #[allow(unused_mut)]
13561        let mut request = self
13562            .client
13563            .post(url)
13564            .header(
13565                ::reqwest::header::ACCEPT,
13566                ::reqwest::header::HeaderValue::from_static("application/json"),
13567            )
13568            .query(&progenitor_client::QueryParam::new("_async", &async_))
13569            .query(&progenitor_client::QueryParam::new("_group", &group))
13570            .query(&progenitor_client::QueryParam::new("fs", &fs))
13571            .query(&progenitor_client::QueryParam::new("interval", &interval))
13572            .query(&progenitor_client::QueryParam::new("timeout", &timeout))
13573            .headers(header_map)
13574            .build()?;
13575        let info = OperationInfo {
13576            operation_id: "vfs_poll_interval",
13577        };
13578        self.pre(&mut request, &info).await?;
13579        let result = self.exec(request, &info).await;
13580        self.post(&result, &info).await?;
13581        let response = result?;
13582        match response.status().as_u16() {
13583            200u16 => ResponseValue::from_response(response).await,
13584            400u16..=499u16 => Err(Error::ErrorResponse(
13585                ResponseValue::from_response(response).await?,
13586            )),
13587            500u16..=599u16 => Err(Error::ErrorResponse(
13588                ResponseValue::from_response(response).await?,
13589            )),
13590            _ => Err(Error::UnexpectedResponse(response)),
13591        }
13592    }
13593
13594    ///Inspect upload queue
13595    ///
13596    ///Returns the contents of the VFS upload queue.
13597    ///
13598    ///Sends a `POST` request to `/vfs/queue`
13599    ///
13600    ///Arguments:
13601    /// - `async_`: Run the command asynchronously. Returns a job id
13602    ///   immediately.
13603    /// - `group`: Assign the request to a custom stats group.
13604    /// - `fs`: Optional VFS identifier whose upload queue should be inspected.
13605    pub async fn vfs_queue<'a>(
13606        &'a self,
13607        async_: Option<bool>,
13608        group: Option<&'a str>,
13609        fs: Option<&'a str>,
13610    ) -> Result<ResponseValue<types::VfsQueueResponse>, Error<types::RcError>> {
13611        let url = format!("{}/vfs/queue", self.baseurl,);
13612        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13613        header_map.append(
13614            ::reqwest::header::HeaderName::from_static("api-version"),
13615            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13616        );
13617        #[allow(unused_mut)]
13618        let mut request = self
13619            .client
13620            .post(url)
13621            .header(
13622                ::reqwest::header::ACCEPT,
13623                ::reqwest::header::HeaderValue::from_static("application/json"),
13624            )
13625            .query(&progenitor_client::QueryParam::new("_async", &async_))
13626            .query(&progenitor_client::QueryParam::new("_group", &group))
13627            .query(&progenitor_client::QueryParam::new("fs", &fs))
13628            .headers(header_map)
13629            .build()?;
13630        let info = OperationInfo {
13631            operation_id: "vfs_queue",
13632        };
13633        self.pre(&mut request, &info).await?;
13634        let result = self.exec(request, &info).await;
13635        self.post(&result, &info).await?;
13636        let response = result?;
13637        match response.status().as_u16() {
13638            200u16 => ResponseValue::from_response(response).await,
13639            400u16..=499u16 => Err(Error::ErrorResponse(
13640                ResponseValue::from_response(response).await?,
13641            )),
13642            500u16..=599u16 => Err(Error::ErrorResponse(
13643                ResponseValue::from_response(response).await?,
13644            )),
13645            _ => Err(Error::UnexpectedResponse(response)),
13646        }
13647    }
13648
13649    ///Adjust queue expiry
13650    ///
13651    ///Sets the expiry time of a queued VFS upload item, optionally relative to
13652    /// its current value.
13653    ///
13654    ///Sends a `POST` request to `/vfs/queue-set-expiry`
13655    ///
13656    ///Arguments:
13657    /// - `async_`: Run the command asynchronously. Returns a job id
13658    ///   immediately.
13659    /// - `group`: Assign the request to a custom stats group.
13660    /// - `expiry`: New eligibility time in seconds (may be negative for
13661    ///   immediate upload).
13662    /// - `fs`: Optional VFS identifier for the queued item.
13663    /// - `id`: Queue item ID as returned by `vfs/queue`.
13664    /// - `relative`: Set to true to treat `expiry` as relative to the current
13665    ///   value.
13666    pub async fn vfs_queue_set_expiry<'a>(
13667        &'a self,
13668        async_: Option<bool>,
13669        group: Option<&'a str>,
13670        expiry: f64,
13671        fs: Option<&'a str>,
13672        id: i64,
13673        relative: Option<bool>,
13674    ) -> Result<
13675        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13676        Error<types::RcError>,
13677    > {
13678        let url = format!("{}/vfs/queue-set-expiry", self.baseurl,);
13679        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13680        header_map.append(
13681            ::reqwest::header::HeaderName::from_static("api-version"),
13682            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13683        );
13684        #[allow(unused_mut)]
13685        let mut request = self
13686            .client
13687            .post(url)
13688            .header(
13689                ::reqwest::header::ACCEPT,
13690                ::reqwest::header::HeaderValue::from_static("application/json"),
13691            )
13692            .query(&progenitor_client::QueryParam::new("_async", &async_))
13693            .query(&progenitor_client::QueryParam::new("_group", &group))
13694            .query(&progenitor_client::QueryParam::new("expiry", &expiry))
13695            .query(&progenitor_client::QueryParam::new("fs", &fs))
13696            .query(&progenitor_client::QueryParam::new("id", &id))
13697            .query(&progenitor_client::QueryParam::new("relative", &relative))
13698            .headers(header_map)
13699            .build()?;
13700        let info = OperationInfo {
13701            operation_id: "vfs_queue_set_expiry",
13702        };
13703        self.pre(&mut request, &info).await?;
13704        let result = self.exec(request, &info).await;
13705        self.post(&result, &info).await?;
13706        let response = result?;
13707        match response.status().as_u16() {
13708            200u16 => ResponseValue::from_response(response).await,
13709            400u16..=499u16 => Err(Error::ErrorResponse(
13710                ResponseValue::from_response(response).await?,
13711            )),
13712            500u16..=599u16 => Err(Error::ErrorResponse(
13713                ResponseValue::from_response(response).await?,
13714            )),
13715            _ => Err(Error::UnexpectedResponse(response)),
13716        }
13717    }
13718
13719    ///Refresh directory cache
13720    ///
13721    ///Refreshes one or more directories in the VFS cache, optionally
13722    /// recursively.
13723    ///
13724    ///Sends a `POST` request to `/vfs/refresh`
13725    ///
13726    ///Arguments:
13727    /// - `async_`: Run the command asynchronously. Returns a job id
13728    ///   immediately.
13729    /// - `group`: Assign the request to a custom stats group.
13730    /// - `fs`: Optional VFS identifier whose directory cache should be
13731    ///   refreshed.
13732    /// - `params`: Additional arbitrary parameters allowed.
13733    /// - `recursive`: Set to true to refresh entire directory trees.
13734    pub async fn vfs_refresh<'a>(
13735        &'a self,
13736        async_: Option<bool>,
13737        group: Option<&'a str>,
13738        fs: Option<&'a str>,
13739        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13740        recursive: Option<bool>,
13741    ) -> Result<ResponseValue<types::VfsRefreshResponse>, Error<types::RcError>> {
13742        let url = format!("{}/vfs/refresh", self.baseurl,);
13743        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13744        header_map.append(
13745            ::reqwest::header::HeaderName::from_static("api-version"),
13746            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13747        );
13748        #[allow(unused_mut)]
13749        let mut request = self
13750            .client
13751            .post(url)
13752            .header(
13753                ::reqwest::header::ACCEPT,
13754                ::reqwest::header::HeaderValue::from_static("application/json"),
13755            )
13756            .query(&progenitor_client::QueryParam::new("_async", &async_))
13757            .query(&progenitor_client::QueryParam::new("_group", &group))
13758            .query(&progenitor_client::QueryParam::new("fs", &fs))
13759            .query(&progenitor_client::QueryParam::new("params", &params))
13760            .query(&progenitor_client::QueryParam::new("recursive", &recursive))
13761            .headers(header_map)
13762            .build()?;
13763        let info = OperationInfo {
13764            operation_id: "vfs_refresh",
13765        };
13766        self.pre(&mut request, &info).await?;
13767        let result = self.exec(request, &info).await;
13768        self.post(&result, &info).await?;
13769        let response = result?;
13770        match response.status().as_u16() {
13771            200u16 => ResponseValue::from_response(response).await,
13772            400u16..=499u16 => Err(Error::ErrorResponse(
13773                ResponseValue::from_response(response).await?,
13774            )),
13775            500u16..=599u16 => Err(Error::ErrorResponse(
13776                ResponseValue::from_response(response).await?,
13777            )),
13778            _ => Err(Error::UnexpectedResponse(response)),
13779        }
13780    }
13781
13782    ///Show VFS stats
13783    ///
13784    ///Returns VFS statistics including disk cache usage and metadata cache
13785    /// counters.
13786    ///
13787    ///Sends a `POST` request to `/vfs/stats`
13788    ///
13789    ///Arguments:
13790    /// - `async_`: Run the command asynchronously. Returns a job id
13791    ///   immediately.
13792    /// - `group`: Assign the request to a custom stats group.
13793    /// - `fs`: Optional VFS identifier whose statistics should be returned.
13794    pub async fn vfs_stats<'a>(
13795        &'a self,
13796        async_: Option<bool>,
13797        group: Option<&'a str>,
13798        fs: Option<&'a str>,
13799    ) -> Result<ResponseValue<types::VfsStatsResponse>, Error<types::RcError>> {
13800        let url = format!("{}/vfs/stats", self.baseurl,);
13801        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13802        header_map.append(
13803            ::reqwest::header::HeaderName::from_static("api-version"),
13804            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13805        );
13806        #[allow(unused_mut)]
13807        let mut request = self
13808            .client
13809            .post(url)
13810            .header(
13811                ::reqwest::header::ACCEPT,
13812                ::reqwest::header::HeaderValue::from_static("application/json"),
13813            )
13814            .query(&progenitor_client::QueryParam::new("_async", &async_))
13815            .query(&progenitor_client::QueryParam::new("_group", &group))
13816            .query(&progenitor_client::QueryParam::new("fs", &fs))
13817            .headers(header_map)
13818            .build()?;
13819        let info = OperationInfo {
13820            operation_id: "vfs_stats",
13821        };
13822        self.pre(&mut request, &info).await?;
13823        let result = self.exec(request, &info).await;
13824        self.post(&result, &info).await?;
13825        let response = result?;
13826        match response.status().as_u16() {
13827            200u16 => ResponseValue::from_response(response).await,
13828            400u16..=499u16 => Err(Error::ErrorResponse(
13829                ResponseValue::from_response(response).await?,
13830            )),
13831            500u16..=599u16 => Err(Error::ErrorResponse(
13832                ResponseValue::from_response(response).await?,
13833            )),
13834            _ => Err(Error::UnexpectedResponse(response)),
13835        }
13836    }
13837
13838    ///Install plugin
13839    ///
13840    ///Downloads and installs a plugin into the WebUI from the provided
13841    /// repository URL.
13842    ///
13843    ///Sends a `POST` request to `/pluginsctl/addPlugin`
13844    ///
13845    ///Arguments:
13846    /// - `async_`: Run the command asynchronously. Returns a job id
13847    ///   immediately.
13848    /// - `group`: Assign the request to a custom stats group.
13849    /// - `url`: Repository URL of the plugin to install.
13850    pub async fn pluginsctl_add_plugin<'a>(
13851        &'a self,
13852        async_: Option<bool>,
13853        group: Option<&'a str>,
13854        url: &'a str,
13855    ) -> Result<
13856        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13857        Error<types::RcError>,
13858    > {
13859        let _url = format!("{}/pluginsctl/addPlugin", self.baseurl,);
13860        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13861        header_map.append(
13862            ::reqwest::header::HeaderName::from_static("api-version"),
13863            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13864        );
13865        #[allow(unused_mut)]
13866        let mut request = self
13867            .client
13868            .post(_url)
13869            .header(
13870                ::reqwest::header::ACCEPT,
13871                ::reqwest::header::HeaderValue::from_static("application/json"),
13872            )
13873            .query(&progenitor_client::QueryParam::new("_async", &async_))
13874            .query(&progenitor_client::QueryParam::new("_group", &group))
13875            .query(&progenitor_client::QueryParam::new("url", &url))
13876            .headers(header_map)
13877            .build()?;
13878        let info = OperationInfo {
13879            operation_id: "pluginsctl_add_plugin",
13880        };
13881        self.pre(&mut request, &info).await?;
13882        let result = self.exec(request, &info).await;
13883        self.post(&result, &info).await?;
13884        let response = result?;
13885        match response.status().as_u16() {
13886            200u16 => ResponseValue::from_response(response).await,
13887            400u16..=499u16 => Err(Error::ErrorResponse(
13888                ResponseValue::from_response(response).await?,
13889            )),
13890            500u16..=599u16 => Err(Error::ErrorResponse(
13891                ResponseValue::from_response(response).await?,
13892            )),
13893            _ => Err(Error::UnexpectedResponse(response)),
13894        }
13895    }
13896
13897    ///Filter plugins by MIME type
13898    ///
13899    ///Returns plugins matching the requested MIME type and optional plugin
13900    /// type.
13901    ///
13902    ///Sends a `POST` request to `/pluginsctl/getPluginsForType`
13903    ///
13904    ///Arguments:
13905    /// - `async_`: Run the command asynchronously. Returns a job id
13906    ///   immediately.
13907    /// - `group`: Assign the request to a custom stats group.
13908    /// - `plugin_type`: Filter results by plugin type (e.g. `test`).
13909    /// - `type_`: MIME type to match when listing plugins.
13910    pub async fn pluginsctl_get_plugins_for_type<'a>(
13911        &'a self,
13912        async_: Option<bool>,
13913        group: Option<&'a str>,
13914        plugin_type: Option<&'a str>,
13915        type_: Option<&'a str>,
13916    ) -> Result<ResponseValue<types::PluginsctlGetPluginsForTypeResponse>, Error<types::RcError>>
13917    {
13918        let url = format!("{}/pluginsctl/getPluginsForType", self.baseurl,);
13919        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13920        header_map.append(
13921            ::reqwest::header::HeaderName::from_static("api-version"),
13922            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13923        );
13924        #[allow(unused_mut)]
13925        let mut request = self
13926            .client
13927            .post(url)
13928            .header(
13929                ::reqwest::header::ACCEPT,
13930                ::reqwest::header::HeaderValue::from_static("application/json"),
13931            )
13932            .query(&progenitor_client::QueryParam::new("_async", &async_))
13933            .query(&progenitor_client::QueryParam::new("_group", &group))
13934            .query(&progenitor_client::QueryParam::new(
13935                "pluginType",
13936                &plugin_type,
13937            ))
13938            .query(&progenitor_client::QueryParam::new("type", &type_))
13939            .headers(header_map)
13940            .build()?;
13941        let info = OperationInfo {
13942            operation_id: "pluginsctl_get_plugins_for_type",
13943        };
13944        self.pre(&mut request, &info).await?;
13945        let result = self.exec(request, &info).await;
13946        self.post(&result, &info).await?;
13947        let response = result?;
13948        match response.status().as_u16() {
13949            200u16 => ResponseValue::from_response(response).await,
13950            400u16..=499u16 => Err(Error::ErrorResponse(
13951                ResponseValue::from_response(response).await?,
13952            )),
13953            500u16..=599u16 => Err(Error::ErrorResponse(
13954                ResponseValue::from_response(response).await?,
13955            )),
13956            _ => Err(Error::UnexpectedResponse(response)),
13957        }
13958    }
13959
13960    ///List installed plugins
13961    ///
13962    ///Returns metadata for installed production and test plugins.
13963    ///
13964    ///Sends a `POST` request to `/pluginsctl/listPlugins`
13965    ///
13966    ///Arguments:
13967    /// - `async_`: Run the command asynchronously. Returns a job id
13968    ///   immediately.
13969    /// - `group`: Assign the request to a custom stats group.
13970    pub async fn pluginsctl_list_plugins<'a>(
13971        &'a self,
13972        async_: Option<bool>,
13973        group: Option<&'a str>,
13974    ) -> Result<ResponseValue<types::PluginsctlListPluginsResponse>, Error<types::RcError>> {
13975        let url = format!("{}/pluginsctl/listPlugins", self.baseurl,);
13976        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13977        header_map.append(
13978            ::reqwest::header::HeaderName::from_static("api-version"),
13979            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13980        );
13981        #[allow(unused_mut)]
13982        let mut request = self
13983            .client
13984            .post(url)
13985            .header(
13986                ::reqwest::header::ACCEPT,
13987                ::reqwest::header::HeaderValue::from_static("application/json"),
13988            )
13989            .query(&progenitor_client::QueryParam::new("_async", &async_))
13990            .query(&progenitor_client::QueryParam::new("_group", &group))
13991            .headers(header_map)
13992            .build()?;
13993        let info = OperationInfo {
13994            operation_id: "pluginsctl_list_plugins",
13995        };
13996        self.pre(&mut request, &info).await?;
13997        let result = self.exec(request, &info).await;
13998        self.post(&result, &info).await?;
13999        let response = result?;
14000        match response.status().as_u16() {
14001            200u16 => ResponseValue::from_response(response).await,
14002            400u16..=499u16 => Err(Error::ErrorResponse(
14003                ResponseValue::from_response(response).await?,
14004            )),
14005            500u16..=599u16 => Err(Error::ErrorResponse(
14006                ResponseValue::from_response(response).await?,
14007            )),
14008            _ => Err(Error::UnexpectedResponse(response)),
14009        }
14010    }
14011
14012    ///List installed test plugins
14013    ///
14014    ///Returns metadata for installed test plugins.
14015    ///
14016    ///Sends a `POST` request to `/pluginsctl/listTestPlugins`
14017    ///
14018    ///Arguments:
14019    /// - `async_`: Run the command asynchronously. Returns a job id
14020    ///   immediately.
14021    /// - `group`: Assign the request to a custom stats group.
14022    pub async fn pluginsctl_list_test_plugins<'a>(
14023        &'a self,
14024        async_: Option<bool>,
14025        group: Option<&'a str>,
14026    ) -> Result<ResponseValue<types::PluginsctlListTestPluginsResponse>, Error<types::RcError>>
14027    {
14028        let url = format!("{}/pluginsctl/listTestPlugins", self.baseurl,);
14029        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
14030        header_map.append(
14031            ::reqwest::header::HeaderName::from_static("api-version"),
14032            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
14033        );
14034        #[allow(unused_mut)]
14035        let mut request = self
14036            .client
14037            .post(url)
14038            .header(
14039                ::reqwest::header::ACCEPT,
14040                ::reqwest::header::HeaderValue::from_static("application/json"),
14041            )
14042            .query(&progenitor_client::QueryParam::new("_async", &async_))
14043            .query(&progenitor_client::QueryParam::new("_group", &group))
14044            .headers(header_map)
14045            .build()?;
14046        let info = OperationInfo {
14047            operation_id: "pluginsctl_list_test_plugins",
14048        };
14049        self.pre(&mut request, &info).await?;
14050        let result = self.exec(request, &info).await;
14051        self.post(&result, &info).await?;
14052        let response = result?;
14053        match response.status().as_u16() {
14054            200u16 => ResponseValue::from_response(response).await,
14055            400u16..=499u16 => Err(Error::ErrorResponse(
14056                ResponseValue::from_response(response).await?,
14057            )),
14058            500u16..=599u16 => Err(Error::ErrorResponse(
14059                ResponseValue::from_response(response).await?,
14060            )),
14061            _ => Err(Error::UnexpectedResponse(response)),
14062        }
14063    }
14064
14065    ///Remove plugin
14066    ///
14067    ///Uninstalls a plugin from the WebUI.
14068    ///
14069    ///Sends a `POST` request to `/pluginsctl/removePlugin`
14070    ///
14071    ///Arguments:
14072    /// - `async_`: Run the command asynchronously. Returns a job id
14073    ///   immediately.
14074    /// - `group`: Assign the request to a custom stats group.
14075    /// - `name`: Name of the plugin to uninstall.
14076    pub async fn pluginsctl_remove_plugin<'a>(
14077        &'a self,
14078        async_: Option<bool>,
14079        group: Option<&'a str>,
14080        name: &'a str,
14081    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
14082        let url = format!("{}/pluginsctl/removePlugin", self.baseurl,);
14083        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
14084        header_map.append(
14085            ::reqwest::header::HeaderName::from_static("api-version"),
14086            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
14087        );
14088        #[allow(unused_mut)]
14089        let mut request = self
14090            .client
14091            .post(url)
14092            .header(
14093                ::reqwest::header::ACCEPT,
14094                ::reqwest::header::HeaderValue::from_static("application/json"),
14095            )
14096            .query(&progenitor_client::QueryParam::new("_async", &async_))
14097            .query(&progenitor_client::QueryParam::new("_group", &group))
14098            .query(&progenitor_client::QueryParam::new("name", &name))
14099            .headers(header_map)
14100            .build()?;
14101        let info = OperationInfo {
14102            operation_id: "pluginsctl_remove_plugin",
14103        };
14104        self.pre(&mut request, &info).await?;
14105        let result = self.exec(request, &info).await;
14106        self.post(&result, &info).await?;
14107        let response = result?;
14108        match response.status().as_u16() {
14109            200u16 => Ok(ResponseValue::empty(response)),
14110            400u16..=499u16 => Err(Error::ErrorResponse(
14111                ResponseValue::from_response(response).await?,
14112            )),
14113            500u16..=599u16 => Err(Error::ErrorResponse(
14114                ResponseValue::from_response(response).await?,
14115            )),
14116            _ => Err(Error::UnexpectedResponse(response)),
14117        }
14118    }
14119
14120    ///Remove test plugin
14121    ///
14122    ///Uninstalls a test plugin from the WebUI.
14123    ///
14124    ///Sends a `POST` request to `/pluginsctl/removeTestPlugin`
14125    ///
14126    ///Arguments:
14127    /// - `async_`: Run the command asynchronously. Returns a job id
14128    ///   immediately.
14129    /// - `group`: Assign the request to a custom stats group.
14130    /// - `name`: Name of the test plugin to uninstall.
14131    pub async fn pluginsctl_remove_test_plugin<'a>(
14132        &'a self,
14133        async_: Option<bool>,
14134        group: Option<&'a str>,
14135        name: &'a str,
14136    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
14137        let url = format!("{}/pluginsctl/removeTestPlugin", self.baseurl,);
14138        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
14139        header_map.append(
14140            ::reqwest::header::HeaderName::from_static("api-version"),
14141            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
14142        );
14143        #[allow(unused_mut)]
14144        let mut request = self
14145            .client
14146            .post(url)
14147            .header(
14148                ::reqwest::header::ACCEPT,
14149                ::reqwest::header::HeaderValue::from_static("application/json"),
14150            )
14151            .query(&progenitor_client::QueryParam::new("_async", &async_))
14152            .query(&progenitor_client::QueryParam::new("_group", &group))
14153            .query(&progenitor_client::QueryParam::new("name", &name))
14154            .headers(header_map)
14155            .build()?;
14156        let info = OperationInfo {
14157            operation_id: "pluginsctl_remove_test_plugin",
14158        };
14159        self.pre(&mut request, &info).await?;
14160        let result = self.exec(request, &info).await;
14161        self.post(&result, &info).await?;
14162        let response = result?;
14163        match response.status().as_u16() {
14164            200u16 => Ok(ResponseValue::empty(response)),
14165            400u16..=499u16 => Err(Error::ErrorResponse(
14166                ResponseValue::from_response(response).await?,
14167            )),
14168            500u16..=599u16 => Err(Error::ErrorResponse(
14169                ResponseValue::from_response(response).await?,
14170            )),
14171            _ => Err(Error::UnexpectedResponse(response)),
14172        }
14173    }
14174}
14175
14176/// Items consumers will typically use such as the Client.
14177pub mod prelude {
14178    #[allow(unused_imports)]
14179    pub use super::Client;
14180}
rclone_sdk/lib.rs

rclone_sdk/
lib.rs
