rclone_sdk/
lib.rs

1#[allow(unused_imports)]
2use progenitor_client::{encode_path, ClientHooks, OperationInfo, RequestBuilderExt};
3#[allow(unused_imports)]
4pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
5/// Types used as operation parameters and responses.
6#[allow(clippy::all)]
7pub mod types {
8    /// Error types.
9    pub mod error {
10        /// Error from a `TryFrom` or `FromStr` implementation.
11        pub struct ConversionError(::std::borrow::Cow<'static, str>);
12        impl ::std::error::Error for ConversionError {}
13        impl ::std::fmt::Display for ConversionError {
14            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
15                ::std::fmt::Display::fmt(&self.0, f)
16            }
17        }
18
19        impl ::std::fmt::Debug for ConversionError {
20            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
21                ::std::fmt::Debug::fmt(&self.0, f)
22            }
23        }
24
25        impl From<&'static str> for ConversionError {
26            fn from(value: &'static str) -> Self {
27                Self(value.into())
28            }
29        }
30
31        impl From<String> for ConversionError {
32            fn from(value: String) -> Self {
33                Self(value.into())
34            }
35        }
36    }
37
38    ///`BackendCommandResponse`
39    ///
40    /// <details><summary>JSON schema</summary>
41    ///
42    /// ```json
43    ///{
44    ///  "type": "object",
45    ///  "properties": {
46    ///    "result": {
47    ///      "description": "Backend command result payload"
48    ///    }
49    ///  },
50    ///  "additionalProperties": true
51    ///}
52    /// ```
53    /// </details>
54    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
55    pub struct BackendCommandResponse {
56        ///Backend command result payload
57        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
58        pub result: ::std::option::Option<::serde_json::Value>,
59    }
60
61    impl ::std::convert::From<&BackendCommandResponse> for BackendCommandResponse {
62        fn from(value: &BackendCommandResponse) -> Self {
63            value.clone()
64        }
65    }
66
67    impl ::std::default::Default for BackendCommandResponse {
68        fn default() -> Self {
69            Self {
70                result: Default::default(),
71            }
72        }
73    }
74
75    ///`ConfigGetResponse`
76    ///
77    /// <details><summary>JSON schema</summary>
78    ///
79    /// ```json
80    ///{
81    ///  "type": "object",
82    ///  "required": [
83    ///    "type"
84    ///  ],
85    ///  "properties": {
86    ///    "provider": {
87    ///      "type": "string"
88    ///    },
89    ///    "type": {
90    ///      "type": "string"
91    ///    }
92    ///  },
93    ///  "additionalProperties": true
94    ///}
95    /// ```
96    /// </details>
97    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
98    pub struct ConfigGetResponse {
99        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
100        pub provider: ::std::option::Option<::std::string::String>,
101        #[serde(rename = "type")]
102        pub type_: ::std::string::String,
103    }
104
105    impl ::std::convert::From<&ConfigGetResponse> for ConfigGetResponse {
106        fn from(value: &ConfigGetResponse) -> Self {
107            value.clone()
108        }
109    }
110
111    ///`ConfigListremotesResponse`
112    ///
113    /// <details><summary>JSON schema</summary>
114    ///
115    /// ```json
116    ///{
117    ///  "type": "object",
118    ///  "required": [
119    ///    "remotes"
120    ///  ],
121    ///  "properties": {
122    ///    "remotes": {
123    ///      "type": "array",
124    ///      "items": {
125    ///        "type": "string"
126    ///      }
127    ///    }
128    ///  }
129    ///}
130    /// ```
131    /// </details>
132    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
133    pub struct ConfigListremotesResponse {
134        pub remotes: ::std::vec::Vec<::std::string::String>,
135    }
136
137    impl ::std::convert::From<&ConfigListremotesResponse> for ConfigListremotesResponse {
138        fn from(value: &ConfigListremotesResponse) -> Self {
139            value.clone()
140        }
141    }
142
143    ///`ConfigPathsResponse`
144    ///
145    /// <details><summary>JSON schema</summary>
146    ///
147    /// ```json
148    ///{
149    ///  "type": "object",
150    ///  "required": [
151    ///    "cache",
152    ///    "config",
153    ///    "temp"
154    ///  ],
155    ///  "properties": {
156    ///    "cache": {
157    ///      "type": "string"
158    ///    },
159    ///    "config": {
160    ///      "type": "string"
161    ///    },
162    ///    "temp": {
163    ///      "type": "string"
164    ///    }
165    ///  }
166    ///}
167    /// ```
168    /// </details>
169    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
170    pub struct ConfigPathsResponse {
171        pub cache: ::std::string::String,
172        pub config: ::std::string::String,
173        pub temp: ::std::string::String,
174    }
175
176    impl ::std::convert::From<&ConfigPathsResponse> for ConfigPathsResponse {
177        fn from(value: &ConfigPathsResponse) -> Self {
178            value.clone()
179        }
180    }
181
182    ///`ConfigProvider`
183    ///
184    /// <details><summary>JSON schema</summary>
185    ///
186    /// ```json
187    ///{
188    ///  "type": "object",
189    ///  "required": [
190    ///    "Description",
191    ///    "Name",
192    ///    "Options",
193    ///    "Prefix"
194    ///  ],
195    ///  "properties": {
196    ///    "Aliases": {
197    ///      "type": [
198    ///        "array",
199    ///        "null"
200    ///      ],
201    ///      "items": {
202    ///        "type": "string"
203    ///      }
204    ///    },
205    ///    "CommandHelp": {
206    ///      "type": [
207    ///        "array",
208    ///        "null"
209    ///      ],
210    ///      "items": {
211    ///        "$ref": "#/components/schemas/ConfigProviderCommandHelp"
212    ///      }
213    ///    },
214    ///    "Description": {
215    ///      "type": "string"
216    ///    },
217    ///    "Hide": {
218    ///      "type": "boolean"
219    ///    },
220    ///    "MetadataInfo": {
221    ///      "$ref": "#/components/schemas/ConfigProviderMetadataInfo"
222    ///    },
223    ///    "Name": {
224    ///      "type": "string"
225    ///    },
226    ///    "Options": {
227    ///      "type": "array",
228    ///      "items": {
229    ///        "$ref": "#/components/schemas/ConfigProviderOption"
230    ///      }
231    ///    },
232    ///    "Prefix": {
233    ///      "type": "string"
234    ///    }
235    ///  },
236    ///  "additionalProperties": true
237    ///}
238    /// ```
239    /// </details>
240    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
241    pub struct ConfigProvider {
242        #[serde(
243            rename = "Aliases",
244            default,
245            skip_serializing_if = "::std::option::Option::is_none"
246        )]
247        pub aliases: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
248        #[serde(
249            rename = "CommandHelp",
250            default,
251            skip_serializing_if = "::std::option::Option::is_none"
252        )]
253        pub command_help: ::std::option::Option<::std::vec::Vec<ConfigProviderCommandHelp>>,
254        #[serde(rename = "Description")]
255        pub description: ::std::string::String,
256        #[serde(
257            rename = "Hide",
258            default,
259            skip_serializing_if = "::std::option::Option::is_none"
260        )]
261        pub hide: ::std::option::Option<bool>,
262        #[serde(
263            rename = "MetadataInfo",
264            default,
265            skip_serializing_if = "::std::option::Option::is_none"
266        )]
267        pub metadata_info: ::std::option::Option<ConfigProviderMetadataInfo>,
268        #[serde(rename = "Name")]
269        pub name: ::std::string::String,
270        #[serde(rename = "Options")]
271        pub options: ::std::vec::Vec<ConfigProviderOption>,
272        #[serde(rename = "Prefix")]
273        pub prefix: ::std::string::String,
274    }
275
276    impl ::std::convert::From<&ConfigProvider> for ConfigProvider {
277        fn from(value: &ConfigProvider) -> Self {
278            value.clone()
279        }
280    }
281
282    ///`ConfigProviderCommandHelp`
283    ///
284    /// <details><summary>JSON schema</summary>
285    ///
286    /// ```json
287    ///{
288    ///  "type": "object",
289    ///  "properties": {
290    ///    "Long": {
291    ///      "type": "string"
292    ///    },
293    ///    "Name": {
294    ///      "type": "string"
295    ///    },
296    ///    "Opts": {
297    ///      "type": [
298    ///        "object",
299    ///        "null"
300    ///      ],
301    ///      "additionalProperties": true
302    ///    },
303    ///    "Short": {
304    ///      "type": "string"
305    ///    }
306    ///  },
307    ///  "additionalProperties": true
308    ///}
309    /// ```
310    /// </details>
311    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
312    pub struct ConfigProviderCommandHelp {
313        #[serde(
314            rename = "Long",
315            default,
316            skip_serializing_if = "::std::option::Option::is_none"
317        )]
318        pub long: ::std::option::Option<::std::string::String>,
319        #[serde(
320            rename = "Name",
321            default,
322            skip_serializing_if = "::std::option::Option::is_none"
323        )]
324        pub name: ::std::option::Option<::std::string::String>,
325        #[serde(
326            rename = "Opts",
327            default,
328            skip_serializing_if = "::std::option::Option::is_none"
329        )]
330        pub opts:
331            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
332        #[serde(
333            rename = "Short",
334            default,
335            skip_serializing_if = "::std::option::Option::is_none"
336        )]
337        pub short: ::std::option::Option<::std::string::String>,
338    }
339
340    impl ::std::convert::From<&ConfigProviderCommandHelp> for ConfigProviderCommandHelp {
341        fn from(value: &ConfigProviderCommandHelp) -> Self {
342            value.clone()
343        }
344    }
345
346    impl ::std::default::Default for ConfigProviderCommandHelp {
347        fn default() -> Self {
348            Self {
349                long: Default::default(),
350                name: Default::default(),
351                opts: Default::default(),
352                short: Default::default(),
353            }
354        }
355    }
356
357    ///`ConfigProviderMetadataInfo`
358    ///
359    /// <details><summary>JSON schema</summary>
360    ///
361    /// ```json
362    ///{
363    ///  "type": "object",
364    ///  "properties": {
365    ///    "Help": {
366    ///      "type": "string"
367    ///    },
368    ///    "System": {
369    ///      "type": [
370    ///        "object",
371    ///        "null"
372    ///      ],
373    ///      "additionalProperties": {
374    ///        "$ref": "#/components/schemas/ConfigProviderMetadataSystemEntry"
375    ///      }
376    ///    }
377    ///  },
378    ///  "additionalProperties": true
379    ///}
380    /// ```
381    /// </details>
382    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
383    pub struct ConfigProviderMetadataInfo {
384        #[serde(
385            rename = "Help",
386            default,
387            skip_serializing_if = "::std::option::Option::is_none"
388        )]
389        pub help: ::std::option::Option<::std::string::String>,
390        #[serde(
391            rename = "System",
392            default,
393            skip_serializing_if = "::std::option::Option::is_none"
394        )]
395        pub system: ::std::option::Option<
396            ::std::collections::HashMap<::std::string::String, ConfigProviderMetadataSystemEntry>,
397        >,
398    }
399
400    impl ::std::convert::From<&ConfigProviderMetadataInfo> for ConfigProviderMetadataInfo {
401        fn from(value: &ConfigProviderMetadataInfo) -> Self {
402            value.clone()
403        }
404    }
405
406    impl ::std::default::Default for ConfigProviderMetadataInfo {
407        fn default() -> Self {
408            Self {
409                help: Default::default(),
410                system: Default::default(),
411            }
412        }
413    }
414
415    ///`ConfigProviderMetadataSystemEntry`
416    ///
417    /// <details><summary>JSON schema</summary>
418    ///
419    /// ```json
420    ///{
421    ///  "type": "object",
422    ///  "properties": {
423    ///    "Example": {
424    ///      "type": "string"
425    ///    },
426    ///    "Help": {
427    ///      "type": "string"
428    ///    },
429    ///    "ReadOnly": {
430    ///      "type": "boolean"
431    ///    },
432    ///    "Type": {
433    ///      "type": "string"
434    ///    }
435    ///  },
436    ///  "additionalProperties": true
437    ///}
438    /// ```
439    /// </details>
440    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
441    pub struct ConfigProviderMetadataSystemEntry {
442        #[serde(
443            rename = "Example",
444            default,
445            skip_serializing_if = "::std::option::Option::is_none"
446        )]
447        pub example: ::std::option::Option<::std::string::String>,
448        #[serde(
449            rename = "Help",
450            default,
451            skip_serializing_if = "::std::option::Option::is_none"
452        )]
453        pub help: ::std::option::Option<::std::string::String>,
454        #[serde(
455            rename = "ReadOnly",
456            default,
457            skip_serializing_if = "::std::option::Option::is_none"
458        )]
459        pub read_only: ::std::option::Option<bool>,
460        #[serde(
461            rename = "Type",
462            default,
463            skip_serializing_if = "::std::option::Option::is_none"
464        )]
465        pub type_: ::std::option::Option<::std::string::String>,
466    }
467
468    impl ::std::convert::From<&ConfigProviderMetadataSystemEntry>
469        for ConfigProviderMetadataSystemEntry
470    {
471        fn from(value: &ConfigProviderMetadataSystemEntry) -> Self {
472            value.clone()
473        }
474    }
475
476    impl ::std::default::Default for ConfigProviderMetadataSystemEntry {
477        fn default() -> Self {
478            Self {
479                example: Default::default(),
480                help: Default::default(),
481                read_only: Default::default(),
482                type_: Default::default(),
483            }
484        }
485    }
486
487    ///`ConfigProviderOption`
488    ///
489    /// <details><summary>JSON schema</summary>
490    ///
491    /// ```json
492    ///{
493    ///  "type": "object",
494    ///  "required": [
495    ///    "Advanced",
496    ///    "Default",
497    ///    "DefaultStr",
498    ///    "Exclusive",
499    ///    "FieldName",
500    ///    "Help",
501    ///    "Hide",
502    ///    "IsPassword",
503    ///    "Name",
504    ///    "NoPrefix",
505    ///    "Required",
506    ///    "Sensitive",
507    ///    "Type",
508    ///    "Value",
509    ///    "ValueStr"
510    ///  ],
511    ///  "properties": {
512    ///    "Advanced": {
513    ///      "type": "boolean"
514    ///    },
515    ///    "Default": {
516    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
517    ///    },
518    ///    "DefaultStr": {
519    ///      "type": "string"
520    ///    },
521    ///    "Examples": {
522    ///      "type": "array",
523    ///      "items": {
524    ///        "$ref": "#/components/schemas/ConfigProviderOptionExample"
525    ///      }
526    ///    },
527    ///    "Exclusive": {
528    ///      "type": "boolean"
529    ///    },
530    ///    "FieldName": {
531    ///      "type": "string"
532    ///    },
533    ///    "Help": {
534    ///      "type": "string"
535    ///    },
536    ///    "Hide": {
537    ///      "type": "number"
538    ///    },
539    ///    "IsPassword": {
540    ///      "type": "boolean"
541    ///    },
542    ///    "Name": {
543    ///      "type": "string"
544    ///    },
545    ///    "NoPrefix": {
546    ///      "type": "boolean"
547    ///    },
548    ///    "Provider": {
549    ///      "type": "string"
550    ///    },
551    ///    "Required": {
552    ///      "type": "boolean"
553    ///    },
554    ///    "Sensitive": {
555    ///      "type": "boolean"
556    ///    },
557    ///    "ShortOpt": {
558    ///      "type": "string"
559    ///    },
560    ///    "Type": {
561    ///      "$ref": "#/components/schemas/ConfigProviderOptionType"
562    ///    },
563    ///    "Value": {
564    ///      "$ref": "#/components/schemas/ConfigProviderOptionAny"
565    ///    },
566    ///    "ValueStr": {
567    ///      "type": "string"
568    ///    }
569    ///  },
570    ///  "additionalProperties": true
571    ///}
572    /// ```
573    /// </details>
574    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
575    pub struct ConfigProviderOption {
576        #[serde(rename = "Advanced")]
577        pub advanced: bool,
578        #[serde(rename = "Default")]
579        pub default: ConfigProviderOptionAny,
580        #[serde(rename = "DefaultStr")]
581        pub default_str: ::std::string::String,
582        #[serde(
583            rename = "Examples",
584            default,
585            skip_serializing_if = "::std::vec::Vec::is_empty"
586        )]
587        pub examples: ::std::vec::Vec<ConfigProviderOptionExample>,
588        #[serde(rename = "Exclusive")]
589        pub exclusive: bool,
590        #[serde(rename = "FieldName")]
591        pub field_name: ::std::string::String,
592        #[serde(rename = "Help")]
593        pub help: ::std::string::String,
594        #[serde(rename = "Hide")]
595        pub hide: f64,
596        #[serde(rename = "IsPassword")]
597        pub is_password: bool,
598        #[serde(rename = "Name")]
599        pub name: ::std::string::String,
600        #[serde(rename = "NoPrefix")]
601        pub no_prefix: bool,
602        #[serde(
603            rename = "Provider",
604            default,
605            skip_serializing_if = "::std::option::Option::is_none"
606        )]
607        pub provider: ::std::option::Option<::std::string::String>,
608        #[serde(rename = "Required")]
609        pub required: bool,
610        #[serde(rename = "Sensitive")]
611        pub sensitive: bool,
612        #[serde(
613            rename = "ShortOpt",
614            default,
615            skip_serializing_if = "::std::option::Option::is_none"
616        )]
617        pub short_opt: ::std::option::Option<::std::string::String>,
618        #[serde(rename = "Type")]
619        pub type_: ConfigProviderOptionType,
620        #[serde(rename = "Value")]
621        pub value: ConfigProviderOptionAny,
622        #[serde(rename = "ValueStr")]
623        pub value_str: ::std::string::String,
624    }
625
626    impl ::std::convert::From<&ConfigProviderOption> for ConfigProviderOption {
627        fn from(value: &ConfigProviderOption) -> Self {
628            value.clone()
629        }
630    }
631
632    ///Arbitrary JSON value. (arbitrary JSON value)
633    ///
634    /// <details><summary>JSON schema</summary>
635    ///
636    /// ```json
637    ///{
638    ///  "description": "Arbitrary JSON value. (arbitrary JSON value)",
639    ///  "type": [
640    ///    "object",
641    ///    "null"
642    ///  ],
643    ///  "additionalProperties": true
644    ///}
645    /// ```
646    /// </details>
647    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
648    #[serde(transparent)]
649    pub struct ConfigProviderOptionAny(
650        pub ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
651    );
652    impl ::std::ops::Deref for ConfigProviderOptionAny {
653        type Target =
654            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>;
655        fn deref(
656            &self,
657        ) -> &::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
658        {
659            &self.0
660        }
661    }
662
663    impl ::std::convert::From<ConfigProviderOptionAny>
664        for ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>
665    {
666        fn from(value: ConfigProviderOptionAny) -> Self {
667            value.0
668        }
669    }
670
671    impl ::std::convert::From<&ConfigProviderOptionAny> for ConfigProviderOptionAny {
672        fn from(value: &ConfigProviderOptionAny) -> Self {
673            value.clone()
674        }
675    }
676
677    impl
678        ::std::convert::From<
679            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
680        > for ConfigProviderOptionAny
681    {
682        fn from(
683            value: ::std::option::Option<
684                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
685            >,
686        ) -> Self {
687            Self(value)
688        }
689    }
690
691    ///`ConfigProviderOptionExample`
692    ///
693    /// <details><summary>JSON schema</summary>
694    ///
695    /// ```json
696    ///{
697    ///  "type": "object",
698    ///  "required": [
699    ///    "Help",
700    ///    "Value"
701    ///  ],
702    ///  "properties": {
703    ///    "Help": {
704    ///      "type": "string"
705    ///    },
706    ///    "Provider": {
707    ///      "type": "string"
708    ///    },
709    ///    "Value": {
710    ///      "type": "string"
711    ///    }
712    ///  },
713    ///  "additionalProperties": true
714    ///}
715    /// ```
716    /// </details>
717    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
718    pub struct ConfigProviderOptionExample {
719        #[serde(rename = "Help")]
720        pub help: ::std::string::String,
721        #[serde(
722            rename = "Provider",
723            default,
724            skip_serializing_if = "::std::option::Option::is_none"
725        )]
726        pub provider: ::std::option::Option<::std::string::String>,
727        #[serde(rename = "Value")]
728        pub value: ::std::string::String,
729    }
730
731    impl ::std::convert::From<&ConfigProviderOptionExample> for ConfigProviderOptionExample {
732        fn from(value: &ConfigProviderOptionExample) -> Self {
733            value.clone()
734        }
735    }
736
737    ///`ConfigProviderOptionType`
738    ///
739    /// <details><summary>JSON schema</summary>
740    ///
741    /// ```json
742    ///{
743    ///  "type": "string",
744    ///  "enum": [
745    ///    "Bits",
746    ///    "bool",
747    ///    "CommaSepList",
748    ///    "Duration",
749    ///    "Encoding",
750    ///    "int",
751    ///    "mtime|atime|btime|ctime",
752    ///    "SizeSuffix",
753    ///    "SpaceSepList",
754    ///    "string",
755    ///    "stringArray",
756    ///    "Time",
757    ///    "Tristate"
758    ///  ]
759    ///}
760    /// ```
761    /// </details>
762    #[derive(
763        :: serde :: Deserialize,
764        :: serde :: Serialize,
765        Clone,
766        Copy,
767        Debug,
768        Eq,
769        Hash,
770        Ord,
771        PartialEq,
772        PartialOrd,
773    )]
774    pub enum ConfigProviderOptionType {
775        Bits,
776        #[serde(rename = "bool")]
777        Bool,
778        CommaSepList,
779        Duration,
780        Encoding,
781        #[serde(rename = "int")]
782        Int,
783        #[serde(rename = "mtime|atime|btime|ctime")]
784        MtimeAtimeBtimeCtime,
785        SizeSuffix,
786        SpaceSepList,
787        #[serde(rename = "string")]
788        String,
789        #[serde(rename = "stringArray")]
790        StringArray,
791        Time,
792        Tristate,
793    }
794
795    impl ::std::convert::From<&Self> for ConfigProviderOptionType {
796        fn from(value: &ConfigProviderOptionType) -> Self {
797            value.clone()
798        }
799    }
800
801    impl ::std::fmt::Display for ConfigProviderOptionType {
802        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
803            match *self {
804                Self::Bits => f.write_str("Bits"),
805                Self::Bool => f.write_str("bool"),
806                Self::CommaSepList => f.write_str("CommaSepList"),
807                Self::Duration => f.write_str("Duration"),
808                Self::Encoding => f.write_str("Encoding"),
809                Self::Int => f.write_str("int"),
810                Self::MtimeAtimeBtimeCtime => f.write_str("mtime|atime|btime|ctime"),
811                Self::SizeSuffix => f.write_str("SizeSuffix"),
812                Self::SpaceSepList => f.write_str("SpaceSepList"),
813                Self::String => f.write_str("string"),
814                Self::StringArray => f.write_str("stringArray"),
815                Self::Time => f.write_str("Time"),
816                Self::Tristate => f.write_str("Tristate"),
817            }
818        }
819    }
820
821    impl ::std::str::FromStr for ConfigProviderOptionType {
822        type Err = self::error::ConversionError;
823        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
824            match value {
825                "Bits" => Ok(Self::Bits),
826                "bool" => Ok(Self::Bool),
827                "CommaSepList" => Ok(Self::CommaSepList),
828                "Duration" => Ok(Self::Duration),
829                "Encoding" => Ok(Self::Encoding),
830                "int" => Ok(Self::Int),
831                "mtime|atime|btime|ctime" => Ok(Self::MtimeAtimeBtimeCtime),
832                "SizeSuffix" => Ok(Self::SizeSuffix),
833                "SpaceSepList" => Ok(Self::SpaceSepList),
834                "string" => Ok(Self::String),
835                "stringArray" => Ok(Self::StringArray),
836                "Time" => Ok(Self::Time),
837                "Tristate" => Ok(Self::Tristate),
838                _ => Err("invalid value".into()),
839            }
840        }
841    }
842
843    impl ::std::convert::TryFrom<&str> for ConfigProviderOptionType {
844        type Error = self::error::ConversionError;
845        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
846            value.parse()
847        }
848    }
849
850    impl ::std::convert::TryFrom<&::std::string::String> for ConfigProviderOptionType {
851        type Error = self::error::ConversionError;
852        fn try_from(
853            value: &::std::string::String,
854        ) -> ::std::result::Result<Self, self::error::ConversionError> {
855            value.parse()
856        }
857    }
858
859    impl ::std::convert::TryFrom<::std::string::String> for ConfigProviderOptionType {
860        type Error = self::error::ConversionError;
861        fn try_from(
862            value: ::std::string::String,
863        ) -> ::std::result::Result<Self, self::error::ConversionError> {
864            value.parse()
865        }
866    }
867
868    ///`ConfigProvidersResponse`
869    ///
870    /// <details><summary>JSON schema</summary>
871    ///
872    /// ```json
873    ///{
874    ///  "type": "object",
875    ///  "required": [
876    ///    "providers"
877    ///  ],
878    ///  "properties": {
879    ///    "providers": {
880    ///      "type": "array",
881    ///      "items": {
882    ///        "$ref": "#/components/schemas/ConfigProvider"
883    ///      }
884    ///    }
885    ///  },
886    ///  "additionalProperties": true
887    ///}
888    /// ```
889    /// </details>
890    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
891    pub struct ConfigProvidersResponse {
892        pub providers: ::std::vec::Vec<ConfigProvider>,
893    }
894
895    impl ::std::convert::From<&ConfigProvidersResponse> for ConfigProvidersResponse {
896        fn from(value: &ConfigProvidersResponse) -> Self {
897            value.clone()
898        }
899    }
900
901    ///`CoreBwlimitResponse`
902    ///
903    /// <details><summary>JSON schema</summary>
904    ///
905    /// ```json
906    ///{
907    ///  "type": "object",
908    ///  "required": [
909    ///    "bytesPerSecond",
910    ///    "bytesPerSecondRx",
911    ///    "bytesPerSecondTx",
912    ///    "rate"
913    ///  ],
914    ///  "properties": {
915    ///    "bytesPerSecond": {
916    ///      "type": "integer"
917    ///    },
918    ///    "bytesPerSecondRx": {
919    ///      "type": "integer"
920    ///    },
921    ///    "bytesPerSecondTx": {
922    ///      "type": "integer"
923    ///    },
924    ///    "rate": {
925    ///      "type": "string"
926    ///    }
927    ///  }
928    ///}
929    /// ```
930    /// </details>
931    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
932    pub struct CoreBwlimitResponse {
933        #[serde(rename = "bytesPerSecond")]
934        pub bytes_per_second: i64,
935        #[serde(rename = "bytesPerSecondRx")]
936        pub bytes_per_second_rx: i64,
937        #[serde(rename = "bytesPerSecondTx")]
938        pub bytes_per_second_tx: i64,
939        pub rate: ::std::string::String,
940    }
941
942    impl ::std::convert::From<&CoreBwlimitResponse> for CoreBwlimitResponse {
943        fn from(value: &CoreBwlimitResponse) -> Self {
944            value.clone()
945        }
946    }
947
948    ///`CoreCommandResponse`
949    ///
950    /// <details><summary>JSON schema</summary>
951    ///
952    /// ```json
953    ///{
954    ///  "type": "object",
955    ///  "required": [
956    ///    "error"
957    ///  ],
958    ///  "properties": {
959    ///    "error": {
960    ///      "type": "boolean"
961    ///    },
962    ///    "result": {
963    ///      "type": [
964    ///        "string",
965    ///        "null"
966    ///      ]
967    ///    },
968    ///    "returnType": {
969    ///      "type": [
970    ///        "string",
971    ///        "null"
972    ///      ]
973    ///    }
974    ///  }
975    ///}
976    /// ```
977    /// </details>
978    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
979    pub struct CoreCommandResponse {
980        pub error: bool,
981        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
982        pub result: ::std::option::Option<::std::string::String>,
983        #[serde(
984            rename = "returnType",
985            default,
986            skip_serializing_if = "::std::option::Option::is_none"
987        )]
988        pub return_type: ::std::option::Option<::std::string::String>,
989    }
990
991    impl ::std::convert::From<&CoreCommandResponse> for CoreCommandResponse {
992        fn from(value: &CoreCommandResponse) -> Self {
993            value.clone()
994        }
995    }
996
997    ///`CoreDuResponse`
998    ///
999    /// <details><summary>JSON schema</summary>
1000    ///
1001    /// ```json
1002    ///{
1003    ///  "type": "object",
1004    ///  "required": [
1005    ///    "dir",
1006    ///    "info"
1007    ///  ],
1008    ///  "properties": {
1009    ///    "dir": {
1010    ///      "type": "string"
1011    ///    },
1012    ///    "info": {
1013    ///      "type": "object",
1014    ///      "required": [
1015    ///        "Available",
1016    ///        "Free",
1017    ///        "Total"
1018    ///      ],
1019    ///      "properties": {
1020    ///        "Available": {
1021    ///          "type": "integer"
1022    ///        },
1023    ///        "Free": {
1024    ///          "type": "integer"
1025    ///        },
1026    ///        "Total": {
1027    ///          "type": "integer"
1028    ///        }
1029    ///      }
1030    ///    }
1031    ///  }
1032    ///}
1033    /// ```
1034    /// </details>
1035    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1036    pub struct CoreDuResponse {
1037        pub dir: ::std::string::String,
1038        pub info: CoreDuResponseInfo,
1039    }
1040
1041    impl ::std::convert::From<&CoreDuResponse> for CoreDuResponse {
1042        fn from(value: &CoreDuResponse) -> Self {
1043            value.clone()
1044        }
1045    }
1046
1047    ///`CoreDuResponseInfo`
1048    ///
1049    /// <details><summary>JSON schema</summary>
1050    ///
1051    /// ```json
1052    ///{
1053    ///  "type": "object",
1054    ///  "required": [
1055    ///    "Available",
1056    ///    "Free",
1057    ///    "Total"
1058    ///  ],
1059    ///  "properties": {
1060    ///    "Available": {
1061    ///      "type": "integer"
1062    ///    },
1063    ///    "Free": {
1064    ///      "type": "integer"
1065    ///    },
1066    ///    "Total": {
1067    ///      "type": "integer"
1068    ///    }
1069    ///  }
1070    ///}
1071    /// ```
1072    /// </details>
1073    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1074    pub struct CoreDuResponseInfo {
1075        #[serde(rename = "Available")]
1076        pub available: i64,
1077        #[serde(rename = "Free")]
1078        pub free: i64,
1079        #[serde(rename = "Total")]
1080        pub total: i64,
1081    }
1082
1083    impl ::std::convert::From<&CoreDuResponseInfo> for CoreDuResponseInfo {
1084        fn from(value: &CoreDuResponseInfo) -> Self {
1085            value.clone()
1086        }
1087    }
1088
1089    ///`CoreGroupListResponse`
1090    ///
1091    /// <details><summary>JSON schema</summary>
1092    ///
1093    /// ```json
1094    ///{
1095    ///  "type": "object",
1096    ///  "required": [
1097    ///    "groups"
1098    ///  ],
1099    ///  "properties": {
1100    ///    "groups": {
1101    ///      "type": "array",
1102    ///      "items": {
1103    ///        "type": "string"
1104    ///      }
1105    ///    }
1106    ///  }
1107    ///}
1108    /// ```
1109    /// </details>
1110    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1111    pub struct CoreGroupListResponse {
1112        pub groups: ::std::vec::Vec<::std::string::String>,
1113    }
1114
1115    impl ::std::convert::From<&CoreGroupListResponse> for CoreGroupListResponse {
1116        fn from(value: &CoreGroupListResponse) -> Self {
1117            value.clone()
1118        }
1119    }
1120
1121    ///`CoreObscureResponse`
1122    ///
1123    /// <details><summary>JSON schema</summary>
1124    ///
1125    /// ```json
1126    ///{
1127    ///  "type": "object",
1128    ///  "required": [
1129    ///    "obscured"
1130    ///  ],
1131    ///  "properties": {
1132    ///    "obscured": {
1133    ///      "type": "string"
1134    ///    }
1135    ///  }
1136    ///}
1137    /// ```
1138    /// </details>
1139    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1140    pub struct CoreObscureResponse {
1141        pub obscured: ::std::string::String,
1142    }
1143
1144    impl ::std::convert::From<&CoreObscureResponse> for CoreObscureResponse {
1145        fn from(value: &CoreObscureResponse) -> Self {
1146            value.clone()
1147        }
1148    }
1149
1150    ///`CorePidResponse`
1151    ///
1152    /// <details><summary>JSON schema</summary>
1153    ///
1154    /// ```json
1155    ///{
1156    ///  "type": "object",
1157    ///  "required": [
1158    ///    "pid"
1159    ///  ],
1160    ///  "properties": {
1161    ///    "pid": {
1162    ///      "type": "integer"
1163    ///    }
1164    ///  }
1165    ///}
1166    /// ```
1167    /// </details>
1168    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1169    pub struct CorePidResponse {
1170        pub pid: i64,
1171    }
1172
1173    impl ::std::convert::From<&CorePidResponse> for CorePidResponse {
1174        fn from(value: &CorePidResponse) -> Self {
1175            value.clone()
1176        }
1177    }
1178
1179    ///Metadata for an item currently undergoing verification.
1180    ///
1181    /// <details><summary>JSON schema</summary>
1182    ///
1183    /// ```json
1184    ///{
1185    ///  "description": "Metadata for an item currently undergoing
1186    /// verification.",
1187    ///  "type": "object",
1188    ///  "properties": {
1189    ///    "group": {
1190    ///      "description": "Stats group name associated with this
1191    /// verification.",
1192    ///      "type": "string"
1193    ///    },
1194    ///    "name": {
1195    ///      "description": "Remote path of the object being verified.",
1196    ///      "type": "string"
1197    ///    },
1198    ///    "size": {
1199    ///      "description": "Total size in bytes of the object.",
1200    ///      "type": "number"
1201    ///    }
1202    ///  },
1203    ///  "additionalProperties": true
1204    ///}
1205    /// ```
1206    /// </details>
1207    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1208    pub struct CoreStatsChecking {
1209        ///Stats group name associated with this verification.
1210        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1211        pub group: ::std::option::Option<::std::string::String>,
1212        ///Remote path of the object being verified.
1213        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1214        pub name: ::std::option::Option<::std::string::String>,
1215        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1216        pub size: ::std::option::Option<f64>,
1217    }
1218
1219    impl ::std::convert::From<&CoreStatsChecking> for CoreStatsChecking {
1220        fn from(value: &CoreStatsChecking) -> Self {
1221            value.clone()
1222        }
1223    }
1224
1225    impl ::std::default::Default for CoreStatsChecking {
1226        fn default() -> Self {
1227            Self {
1228                group: Default::default(),
1229                name: Default::default(),
1230                size: Default::default(),
1231            }
1232        }
1233    }
1234
1235    ///`CoreStatsResponse`
1236    ///
1237    /// <details><summary>JSON schema</summary>
1238    ///
1239    /// ```json
1240    ///{
1241    ///  "type": "object",
1242    ///  "required": [
1243    ///    "bytes",
1244    ///    "checks",
1245    ///    "deletedDirs",
1246    ///    "deletes",
1247    ///    "elapsedTime",
1248    ///    "errors",
1249    ///    "eta",
1250    ///    "fatalError",
1251    ///    "renames",
1252    ///    "retryError",
1253    ///    "serverSideCopies",
1254    ///    "serverSideCopyBytes",
1255    ///    "serverSideMoveBytes",
1256    ///    "serverSideMoves",
1257    ///    "speed",
1258    ///    "totalBytes",
1259    ///    "totalChecks",
1260    ///    "totalTransfers",
1261    ///    "transferTime",
1262    ///    "transfers"
1263    ///  ],
1264    ///  "properties": {
1265    ///    "bytes": {
1266    ///      "type": "number"
1267    ///    },
1268    ///    "checking": {
1269    ///      "description": "Objects currently undergoing verification
1270    /// operations.",
1271    ///      "type": "array",
1272    ///      "items": {
1273    ///        "$ref": "#/components/schemas/CoreStatsChecking"
1274    ///      }
1275    ///    },
1276    ///    "checks": {
1277    ///      "type": "number"
1278    ///    },
1279    ///    "deletedDirs": {
1280    ///      "type": "number"
1281    ///    },
1282    ///    "deletes": {
1283    ///      "type": "number"
1284    ///    },
1285    ///    "elapsedTime": {
1286    ///      "type": "number"
1287    ///    },
1288    ///    "errors": {
1289    ///      "type": "number"
1290    ///    },
1291    ///    "eta": {
1292    ///      "type": [
1293    ///        "number",
1294    ///        "null"
1295    ///      ]
1296    ///    },
1297    ///    "fatalError": {
1298    ///      "type": "boolean"
1299    ///    },
1300    ///    "lastError": {
1301    ///      "type": "string"
1302    ///    },
1303    ///    "renames": {
1304    ///      "type": "number"
1305    ///    },
1306    ///    "retryError": {
1307    ///      "type": "boolean"
1308    ///    },
1309    ///    "serverSideCopies": {
1310    ///      "type": "number"
1311    ///    },
1312    ///    "serverSideCopyBytes": {
1313    ///      "type": "number"
1314    ///    },
1315    ///    "serverSideMoveBytes": {
1316    ///      "type": "number"
1317    ///    },
1318    ///    "serverSideMoves": {
1319    ///      "type": "number"
1320    ///    },
1321    ///    "speed": {
1322    ///      "type": "number"
1323    ///    },
1324    ///    "totalBytes": {
1325    ///      "type": "number"
1326    ///    },
1327    ///    "totalChecks": {
1328    ///      "type": "number"
1329    ///    },
1330    ///    "totalTransfers": {
1331    ///      "type": "number"
1332    ///    },
1333    ///    "transferTime": {
1334    ///      "type": "number"
1335    ///    },
1336    ///    "transferring": {
1337    ///      "description": "Active transfers currently in progress grouped by
1338    /// stats group.",
1339    ///      "type": "array",
1340    ///      "items": {
1341    ///        "$ref": "#/components/schemas/CoreStatsTransfer"
1342    ///      }
1343    ///    },
1344    ///    "transfers": {
1345    ///      "type": "number"
1346    ///    }
1347    ///  }
1348    ///}
1349    /// ```
1350    /// </details>
1351    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1352    pub struct CoreStatsResponse {
1353        pub bytes: f64,
1354        ///Objects currently undergoing verification operations.
1355        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1356        pub checking: ::std::vec::Vec<CoreStatsChecking>,
1357        pub checks: f64,
1358        #[serde(rename = "deletedDirs")]
1359        pub deleted_dirs: f64,
1360        pub deletes: f64,
1361        #[serde(rename = "elapsedTime")]
1362        pub elapsed_time: f64,
1363        pub errors: f64,
1364        pub eta: ::std::option::Option<f64>,
1365        #[serde(rename = "fatalError")]
1366        pub fatal_error: bool,
1367        #[serde(
1368            rename = "lastError",
1369            default,
1370            skip_serializing_if = "::std::option::Option::is_none"
1371        )]
1372        pub last_error: ::std::option::Option<::std::string::String>,
1373        pub renames: f64,
1374        #[serde(rename = "retryError")]
1375        pub retry_error: bool,
1376        #[serde(rename = "serverSideCopies")]
1377        pub server_side_copies: f64,
1378        #[serde(rename = "serverSideCopyBytes")]
1379        pub server_side_copy_bytes: f64,
1380        #[serde(rename = "serverSideMoveBytes")]
1381        pub server_side_move_bytes: f64,
1382        #[serde(rename = "serverSideMoves")]
1383        pub server_side_moves: f64,
1384        pub speed: f64,
1385        #[serde(rename = "totalBytes")]
1386        pub total_bytes: f64,
1387        #[serde(rename = "totalChecks")]
1388        pub total_checks: f64,
1389        #[serde(rename = "totalTransfers")]
1390        pub total_transfers: f64,
1391        #[serde(rename = "transferTime")]
1392        pub transfer_time: f64,
1393        ///Active transfers currently in progress grouped by stats group.
1394        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1395        pub transferring: ::std::vec::Vec<CoreStatsTransfer>,
1396        pub transfers: f64,
1397    }
1398
1399    impl ::std::convert::From<&CoreStatsResponse> for CoreStatsResponse {
1400        fn from(value: &CoreStatsResponse) -> Self {
1401            value.clone()
1402        }
1403    }
1404
1405    ///Progress metrics for an in-flight transfer.
1406    ///
1407    /// <details><summary>JSON schema</summary>
1408    ///
1409    /// ```json
1410    ///{
1411    ///  "description": "Progress metrics for an in-flight transfer.",
1412    ///  "type": "object",
1413    ///  "properties": {
1414    ///    "bytes": {
1415    ///      "description": "Bytes transferred so far for this object.",
1416    ///      "type": "number"
1417    ///    },
1418    ///    "eta": {
1419    ///      "description": "Estimated seconds remaining, when available.",
1420    ///      "type": [
1421    ///        "number",
1422    ///        "null"
1423    ///      ]
1424    ///    },
1425    ///    "group": {
1426    ///      "description": "Stats group name associated with this transfer.",
1427    ///      "type": "string"
1428    ///    },
1429    ///    "name": {
1430    ///      "description": "Remote path of the object being transferred.",
1431    ///      "type": "string"
1432    ///    },
1433    ///    "percentage": {
1434    ///      "description": "Completion percentage from 0-100.",
1435    ///      "type": "number"
1436    ///    },
1437    ///    "size": {
1438    ///      "description": "Total size in bytes of the object.",
1439    ///      "type": "number"
1440    ///    },
1441    ///    "speed": {
1442    ///      "description": "Current transfer speed in bytes per second.",
1443    ///      "type": "number"
1444    ///    }
1445    ///  },
1446    ///  "additionalProperties": true
1447    ///}
1448    /// ```
1449    /// </details>
1450    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1451    pub struct CoreStatsTransfer {
1452        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1453        pub bytes: ::std::option::Option<f64>,
1454        ///Estimated seconds remaining, when available.
1455        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1456        pub eta: ::std::option::Option<f64>,
1457        ///Stats group name associated with this transfer.
1458        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1459        pub group: ::std::option::Option<::std::string::String>,
1460        ///Remote path of the object being transferred.
1461        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1462        pub name: ::std::option::Option<::std::string::String>,
1463        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1464        pub percentage: ::std::option::Option<f64>,
1465        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1466        pub size: ::std::option::Option<f64>,
1467        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1468        pub speed: ::std::option::Option<f64>,
1469    }
1470
1471    impl ::std::convert::From<&CoreStatsTransfer> for CoreStatsTransfer {
1472        fn from(value: &CoreStatsTransfer) -> Self {
1473            value.clone()
1474        }
1475    }
1476
1477    impl ::std::default::Default for CoreStatsTransfer {
1478        fn default() -> Self {
1479            Self {
1480                bytes: Default::default(),
1481                eta: Default::default(),
1482                group: Default::default(),
1483                name: Default::default(),
1484                percentage: Default::default(),
1485                size: Default::default(),
1486                speed: Default::default(),
1487            }
1488        }
1489    }
1490
1491    ///`CoreTransferredResponse`
1492    ///
1493    /// <details><summary>JSON schema</summary>
1494    ///
1495    /// ```json
1496    ///{
1497    ///  "type": "object",
1498    ///  "required": [
1499    ///    "transferred"
1500    ///  ],
1501    ///  "properties": {
1502    ///    "transferred": {
1503    ///      "type": "array",
1504    ///      "items": {
1505    ///        "type": "object",
1506    ///        "required": [
1507    ///          "group"
1508    ///        ],
1509    ///        "properties": {
1510    ///          "bytes": {
1511    ///            "type": "integer"
1512    ///          },
1513    ///          "checked": {
1514    ///            "type": "boolean"
1515    ///          },
1516    ///          "dstFs": {
1517    ///            "description": "Destination remote or filesystem used for the
1518    /// transfer.",
1519    ///            "type": "string"
1520    ///          },
1521    ///          "dstRemote": {
1522    ///            "description": "Destination path within `dstFs`, when
1523    /// provided.",
1524    ///            "type": "string"
1525    ///          },
1526    ///          "error": {
1527    ///            "type": "string"
1528    ///          },
1529    ///          "group": {
1530    ///            "description": "Stats group identifier this transfer belonged
1531    /// to.",
1532    ///            "type": "string"
1533    ///          },
1534    ///          "jobid": {
1535    ///            "type": "integer"
1536    ///          },
1537    ///          "name": {
1538    ///            "type": "string"
1539    ///          },
1540    ///          "size": {
1541    ///            "type": "integer"
1542    ///          },
1543    ///          "srcFs": {
1544    ///            "description": "Source remote or filesystem used for the
1545    /// transfer.",
1546    ///            "type": "string"
1547    ///          },
1548    ///          "srcRemote": {
1549    ///            "description": "Source path within `srcFs`, when provided.",
1550    ///            "type": "string"
1551    ///          },
1552    ///          "timestamp": {
1553    ///            "type": "integer"
1554    ///          },
1555    ///          "what": {
1556    ///            "type": "string"
1557    ///          }
1558    ///        },
1559    ///        "additionalProperties": true
1560    ///      }
1561    ///    }
1562    ///  }
1563    ///}
1564    /// ```
1565    /// </details>
1566    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1567    pub struct CoreTransferredResponse {
1568        pub transferred: ::std::vec::Vec<CoreTransferredResponseTransferredItem>,
1569    }
1570
1571    impl ::std::convert::From<&CoreTransferredResponse> for CoreTransferredResponse {
1572        fn from(value: &CoreTransferredResponse) -> Self {
1573            value.clone()
1574        }
1575    }
1576
1577    ///`CoreTransferredResponseTransferredItem`
1578    ///
1579    /// <details><summary>JSON schema</summary>
1580    ///
1581    /// ```json
1582    ///{
1583    ///  "type": "object",
1584    ///  "required": [
1585    ///    "group"
1586    ///  ],
1587    ///  "properties": {
1588    ///    "bytes": {
1589    ///      "type": "integer"
1590    ///    },
1591    ///    "checked": {
1592    ///      "type": "boolean"
1593    ///    },
1594    ///    "dstFs": {
1595    ///      "description": "Destination remote or filesystem used for the
1596    /// transfer.",
1597    ///      "type": "string"
1598    ///    },
1599    ///    "dstRemote": {
1600    ///      "description": "Destination path within `dstFs`, when provided.",
1601    ///      "type": "string"
1602    ///    },
1603    ///    "error": {
1604    ///      "type": "string"
1605    ///    },
1606    ///    "group": {
1607    ///      "description": "Stats group identifier this transfer belonged to.",
1608    ///      "type": "string"
1609    ///    },
1610    ///    "jobid": {
1611    ///      "type": "integer"
1612    ///    },
1613    ///    "name": {
1614    ///      "type": "string"
1615    ///    },
1616    ///    "size": {
1617    ///      "type": "integer"
1618    ///    },
1619    ///    "srcFs": {
1620    ///      "description": "Source remote or filesystem used for the
1621    /// transfer.",
1622    ///      "type": "string"
1623    ///    },
1624    ///    "srcRemote": {
1625    ///      "description": "Source path within `srcFs`, when provided.",
1626    ///      "type": "string"
1627    ///    },
1628    ///    "timestamp": {
1629    ///      "type": "integer"
1630    ///    },
1631    ///    "what": {
1632    ///      "type": "string"
1633    ///    }
1634    ///  },
1635    ///  "additionalProperties": true
1636    ///}
1637    /// ```
1638    /// </details>
1639    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1640    pub struct CoreTransferredResponseTransferredItem {
1641        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1642        pub bytes: ::std::option::Option<i64>,
1643        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1644        pub checked: ::std::option::Option<bool>,
1645        ///Destination remote or filesystem used for the transfer.
1646        #[serde(
1647            rename = "dstFs",
1648            default,
1649            skip_serializing_if = "::std::option::Option::is_none"
1650        )]
1651        pub dst_fs: ::std::option::Option<::std::string::String>,
1652        ///Destination path within `dstFs`, when provided.
1653        #[serde(
1654            rename = "dstRemote",
1655            default,
1656            skip_serializing_if = "::std::option::Option::is_none"
1657        )]
1658        pub dst_remote: ::std::option::Option<::std::string::String>,
1659        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1660        pub error: ::std::option::Option<::std::string::String>,
1661        ///Stats group identifier this transfer belonged to.
1662        pub group: ::std::string::String,
1663        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1664        pub jobid: ::std::option::Option<i64>,
1665        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1666        pub name: ::std::option::Option<::std::string::String>,
1667        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1668        pub size: ::std::option::Option<i64>,
1669        ///Source remote or filesystem used for the transfer.
1670        #[serde(
1671            rename = "srcFs",
1672            default,
1673            skip_serializing_if = "::std::option::Option::is_none"
1674        )]
1675        pub src_fs: ::std::option::Option<::std::string::String>,
1676        ///Source path within `srcFs`, when provided.
1677        #[serde(
1678            rename = "srcRemote",
1679            default,
1680            skip_serializing_if = "::std::option::Option::is_none"
1681        )]
1682        pub src_remote: ::std::option::Option<::std::string::String>,
1683        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1684        pub timestamp: ::std::option::Option<i64>,
1685        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1686        pub what: ::std::option::Option<::std::string::String>,
1687    }
1688
1689    impl ::std::convert::From<&CoreTransferredResponseTransferredItem>
1690        for CoreTransferredResponseTransferredItem
1691    {
1692        fn from(value: &CoreTransferredResponseTransferredItem) -> Self {
1693            value.clone()
1694        }
1695    }
1696
1697    ///`CoreVersionResponse`
1698    ///
1699    /// <details><summary>JSON schema</summary>
1700    ///
1701    /// ```json
1702    ///{
1703    ///  "type": "object",
1704    ///  "required": [
1705    ///    "arch",
1706    ///    "decomposed",
1707    ///    "goTags",
1708    ///    "goVersion",
1709    ///    "isBeta",
1710    ///    "isGit",
1711    ///    "linking",
1712    ///    "os",
1713    ///    "version"
1714    ///  ],
1715    ///  "properties": {
1716    ///    "arch": {
1717    ///      "description": "CPU architecture (e.g. amd64, arm64).",
1718    ///      "type": "string"
1719    ///    },
1720    ///    "decomposed": {
1721    ///      "description": "Version number broken into components.",
1722    ///      "type": "array",
1723    ///      "items": {
1724    ///        "type": "number"
1725    ///      }
1726    ///    },
1727    ///    "goTags": {
1728    ///      "description": "Space separated Go build tags, if any.",
1729    ///      "type": "string"
1730    ///    },
1731    ///    "goVersion": {
1732    ///      "description": "Go toolchain version used to build rclone.",
1733    ///      "type": "string"
1734    ///    },
1735    ///    "isBeta": {
1736    ///      "description": "Indicates whether this build is a beta version.",
1737    ///      "type": "boolean"
1738    ///    },
1739    ///    "isGit": {
1740    ///      "description": "True when built directly from a git checkout.",
1741    ///      "type": "boolean"
1742    ///    },
1743    ///    "linking": {
1744    ///      "description": "Linking mode for the binary (static or dynamic).",
1745    ///      "type": "string"
1746    ///    },
1747    ///    "os": {
1748    ///      "description": "Operating system rclone is running on (e.g. linux,
1749    /// darwin).",
1750    ///      "type": "string"
1751    ///    },
1752    ///    "osArch": {
1753    ///      "description": "CPU architecture in use (e.g. arm64 (ARMv8
1754    /// compatible)).",
1755    ///      "type": "string"
1756    ///    },
1757    ///    "osKernel": {
1758    ///      "description": "OS Kernel version (e.g. 6.8.0-86-generic
1759    /// (x86_64)).",
1760    ///      "type": "string"
1761    ///    },
1762    ///    "osVersion": {
1763    ///      "description": "OS Version (e.g. ubuntu 24.04 (64 bit)).",
1764    ///      "type": "string"
1765    ///    },
1766    ///    "version": {
1767    ///      "description": "Full semantic version string (e.g. 1.67.0).",
1768    ///      "type": "string"
1769    ///    }
1770    ///  }
1771    ///}
1772    /// ```
1773    /// </details>
1774    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1775    pub struct CoreVersionResponse {
1776        ///CPU architecture (e.g. amd64, arm64).
1777        pub arch: ::std::string::String,
1778        ///Version number broken into components.
1779        pub decomposed: ::std::vec::Vec<f64>,
1780        ///Space separated Go build tags, if any.
1781        #[serde(rename = "goTags")]
1782        pub go_tags: ::std::string::String,
1783        ///Go toolchain version used to build rclone.
1784        #[serde(rename = "goVersion")]
1785        pub go_version: ::std::string::String,
1786        ///Indicates whether this build is a beta version.
1787        #[serde(rename = "isBeta")]
1788        pub is_beta: bool,
1789        ///True when built directly from a git checkout.
1790        #[serde(rename = "isGit")]
1791        pub is_git: bool,
1792        ///Linking mode for the binary (static or dynamic).
1793        pub linking: ::std::string::String,
1794        ///Operating system rclone is running on (e.g. linux, darwin).
1795        pub os: ::std::string::String,
1796        ///CPU architecture in use (e.g. arm64 (ARMv8 compatible)).
1797        #[serde(
1798            rename = "osArch",
1799            default,
1800            skip_serializing_if = "::std::option::Option::is_none"
1801        )]
1802        pub os_arch: ::std::option::Option<::std::string::String>,
1803        ///OS Kernel version (e.g. 6.8.0-86-generic (x86_64)).
1804        #[serde(
1805            rename = "osKernel",
1806            default,
1807            skip_serializing_if = "::std::option::Option::is_none"
1808        )]
1809        pub os_kernel: ::std::option::Option<::std::string::String>,
1810        ///OS Version (e.g. ubuntu 24.04 (64 bit)).
1811        #[serde(
1812            rename = "osVersion",
1813            default,
1814            skip_serializing_if = "::std::option::Option::is_none"
1815        )]
1816        pub os_version: ::std::option::Option<::std::string::String>,
1817        ///Full semantic version string (e.g. 1.67.0).
1818        pub version: ::std::string::String,
1819    }
1820
1821    impl ::std::convert::From<&CoreVersionResponse> for CoreVersionResponse {
1822        fn from(value: &CoreVersionResponse) -> Self {
1823            value.clone()
1824        }
1825    }
1826
1827    ///`DebugSetGcPercentResponse`
1828    ///
1829    /// <details><summary>JSON schema</summary>
1830    ///
1831    /// ```json
1832    ///{
1833    ///  "type": "object",
1834    ///  "required": [
1835    ///    "existing-gc-percent"
1836    ///  ],
1837    ///  "properties": {
1838    ///    "existing-gc-percent": {
1839    ///      "type": "integer"
1840    ///    }
1841    ///  }
1842    ///}
1843    /// ```
1844    /// </details>
1845    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1846    pub struct DebugSetGcPercentResponse {
1847        #[serde(rename = "existing-gc-percent")]
1848        pub existing_gc_percent: i64,
1849    }
1850
1851    impl ::std::convert::From<&DebugSetGcPercentResponse> for DebugSetGcPercentResponse {
1852        fn from(value: &DebugSetGcPercentResponse) -> Self {
1853            value.clone()
1854        }
1855    }
1856
1857    ///`DebugSetMutexProfileFractionResponse`
1858    ///
1859    /// <details><summary>JSON schema</summary>
1860    ///
1861    /// ```json
1862    ///{
1863    ///  "type": "object",
1864    ///  "required": [
1865    ///    "previousRate"
1866    ///  ],
1867    ///  "properties": {
1868    ///    "previousRate": {
1869    ///      "type": "integer"
1870    ///    }
1871    ///  }
1872    ///}
1873    /// ```
1874    /// </details>
1875    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1876    pub struct DebugSetMutexProfileFractionResponse {
1877        #[serde(rename = "previousRate")]
1878        pub previous_rate: i64,
1879    }
1880
1881    impl ::std::convert::From<&DebugSetMutexProfileFractionResponse>
1882        for DebugSetMutexProfileFractionResponse
1883    {
1884        fn from(value: &DebugSetMutexProfileFractionResponse) -> Self {
1885            value.clone()
1886        }
1887    }
1888
1889    ///`DebugSetSoftMemoryLimitResponse`
1890    ///
1891    /// <details><summary>JSON schema</summary>
1892    ///
1893    /// ```json
1894    ///{
1895    ///  "type": "object",
1896    ///  "required": [
1897    ///    "existing-mem-limit"
1898    ///  ],
1899    ///  "properties": {
1900    ///    "existing-mem-limit": {
1901    ///      "type": "integer"
1902    ///    }
1903    ///  }
1904    ///}
1905    /// ```
1906    /// </details>
1907    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1908    pub struct DebugSetSoftMemoryLimitResponse {
1909        #[serde(rename = "existing-mem-limit")]
1910        pub existing_mem_limit: i64,
1911    }
1912
1913    impl ::std::convert::From<&DebugSetSoftMemoryLimitResponse> for DebugSetSoftMemoryLimitResponse {
1914        fn from(value: &DebugSetSoftMemoryLimitResponse) -> Self {
1915            value.clone()
1916        }
1917    }
1918
1919    ///`FscacheEntriesResponse`
1920    ///
1921    /// <details><summary>JSON schema</summary>
1922    ///
1923    /// ```json
1924    ///{
1925    ///  "type": "object",
1926    ///  "required": [
1927    ///    "entries"
1928    ///  ],
1929    ///  "properties": {
1930    ///    "entries": {
1931    ///      "type": "integer"
1932    ///    }
1933    ///  }
1934    ///}
1935    /// ```
1936    /// </details>
1937    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1938    pub struct FscacheEntriesResponse {
1939        pub entries: i64,
1940    }
1941
1942    impl ::std::convert::From<&FscacheEntriesResponse> for FscacheEntriesResponse {
1943        fn from(value: &FscacheEntriesResponse) -> Self {
1944            value.clone()
1945        }
1946    }
1947
1948    ///`JobBatchInputsItem`
1949    ///
1950    /// <details><summary>JSON schema</summary>
1951    ///
1952    /// ```json
1953    ///{
1954    ///  "type": "object",
1955    ///  "required": [
1956    ///    "_path"
1957    ///  ],
1958    ///  "properties": {
1959    ///    "_path": {
1960    ///      "description": "rc/path",
1961    ///      "type": "string"
1962    ///    }
1963    ///  },
1964    ///  "additionalProperties": true
1965    ///}
1966    /// ```
1967    /// </details>
1968    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1969    pub struct JobBatchInputsItem {
1970        ///rc/path
1971        #[serde(rename = "_path")]
1972        pub path: ::std::string::String,
1973    }
1974
1975    impl ::std::convert::From<&JobBatchInputsItem> for JobBatchInputsItem {
1976        fn from(value: &JobBatchInputsItem) -> Self {
1977            value.clone()
1978        }
1979    }
1980
1981    ///`JobBatchResponse`
1982    ///
1983    /// <details><summary>JSON schema</summary>
1984    ///
1985    /// ```json
1986    ///{
1987    ///  "type": "object",
1988    ///  "properties": {
1989    ///    "results": {
1990    ///      "type": "array",
1991    ///      "items": {
1992    ///        "type": "object",
1993    ///        "additionalProperties": true
1994    ///      }
1995    ///    }
1996    ///  }
1997    ///}
1998    /// ```
1999    /// </details>
2000    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2001    pub struct JobBatchResponse {
2002        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2003        pub results: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
2004    }
2005
2006    impl ::std::convert::From<&JobBatchResponse> for JobBatchResponse {
2007        fn from(value: &JobBatchResponse) -> Self {
2008            value.clone()
2009        }
2010    }
2011
2012    impl ::std::default::Default for JobBatchResponse {
2013        fn default() -> Self {
2014            Self {
2015                results: Default::default(),
2016            }
2017        }
2018    }
2019
2020    ///`JobListResponse`
2021    ///
2022    /// <details><summary>JSON schema</summary>
2023    ///
2024    /// ```json
2025    ///{
2026    ///  "type": "object",
2027    ///  "required": [
2028    ///    "executeId",
2029    ///    "finishedIds",
2030    ///    "jobids",
2031    ///    "runningIds"
2032    ///  ],
2033    ///  "properties": {
2034    ///    "executeId": {
2035    ///      "description": "Identifier for this rclone process.",
2036    ///      "type": "string"
2037    ///    },
2038    ///    "finishedIds": {
2039    ///      "description": "Array of integer job ids that are finished.",
2040    ///      "type": "array",
2041    ///      "items": {
2042    ///        "type": "integer"
2043    ///      }
2044    ///    },
2045    ///    "jobids": {
2046    ///      "description": "Job IDs suitable for use with `job/status` and
2047    /// `job/stop`.",
2048    ///      "type": "array",
2049    ///      "items": {
2050    ///        "type": "number"
2051    ///      }
2052    ///    },
2053    ///    "runningIds": {
2054    ///      "description": "Array of integer job ids that are running.",
2055    ///      "type": "array",
2056    ///      "items": {
2057    ///        "type": "integer"
2058    ///      }
2059    ///    }
2060    ///  }
2061    ///}
2062    /// ```
2063    /// </details>
2064    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2065    pub struct JobListResponse {
2066        ///Identifier for this rclone process.
2067        #[serde(rename = "executeId")]
2068        pub execute_id: ::std::string::String,
2069        ///Array of integer job ids that are finished.
2070        #[serde(rename = "finishedIds")]
2071        pub finished_ids: ::std::vec::Vec<i64>,
2072        ///Job IDs suitable for use with `job/status` and `job/stop`.
2073        pub jobids: ::std::vec::Vec<f64>,
2074        ///Array of integer job ids that are running.
2075        #[serde(rename = "runningIds")]
2076        pub running_ids: ::std::vec::Vec<i64>,
2077    }
2078
2079    impl ::std::convert::From<&JobListResponse> for JobListResponse {
2080        fn from(value: &JobListResponse) -> Self {
2081            value.clone()
2082        }
2083    }
2084
2085    ///`JobStatusResponse`
2086    ///
2087    /// <details><summary>JSON schema</summary>
2088    ///
2089    /// ```json
2090    ///{
2091    ///  "type": "object",
2092    ///  "required": [
2093    ///    "duration",
2094    ///    "endTime",
2095    ///    "error",
2096    ///    "finished",
2097    ///    "id",
2098    ///    "startTime",
2099    ///    "success"
2100    ///  ],
2101    ///  "properties": {
2102    ///    "duration": {
2103    ///      "description": "Execution time in seconds.",
2104    ///      "type": "number"
2105    ///    },
2106    ///    "endTime": {
2107    ///      "description": "Timestamp when the job finished. (e.g.
2108    /// '2025-12-26T18:50:20.528746884+01:00')",
2109    ///      "type": "string"
2110    ///    },
2111    ///    "error": {
2112    ///      "description": "Error message, or empty string on success.",
2113    ///      "type": "string"
2114    ///    },
2115    ///    "finished": {
2116    ///      "description": "True once the job has completed.",
2117    ///      "type": "boolean"
2118    ///    },
2119    ///    "id": {
2120    ///      "description": "Job identifier.",
2121    ///      "type": "number"
2122    ///    },
2123    ///    "output": {
2124    ///      "description": "Synchronous-style output payload when available."
2125    ///    },
2126    ///    "progress": {
2127    ///      "description": "Progress measurements supplied by the underlying
2128    /// command."
2129    ///    },
2130    ///    "startTime": {
2131    ///      "description": "Timestamp when the job started. (e.g.
2132    /// '2025-12-24T18:50:20.5281314+01:00')",
2133    ///      "type": "string"
2134    ///    },
2135    ///    "success": {
2136    ///      "description": "True if the job completed successfully.",
2137    ///      "type": "boolean"
2138    ///    }
2139    ///  }
2140    ///}
2141    /// ```
2142    /// </details>
2143    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2144    pub struct JobStatusResponse {
2145        pub duration: f64,
2146        ///Timestamp when the job finished. (e.g.
2147        /// '2025-12-26T18:50:20.528746884+01:00')
2148        #[serde(rename = "endTime")]
2149        pub end_time: ::std::string::String,
2150        ///Error message, or empty string on success.
2151        pub error: ::std::string::String,
2152        ///True once the job has completed.
2153        pub finished: bool,
2154        pub id: f64,
2155        ///Synchronous-style output payload when available.
2156        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2157        pub output: ::std::option::Option<::serde_json::Value>,
2158        ///Progress measurements supplied by the underlying command.
2159        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2160        pub progress: ::std::option::Option<::serde_json::Value>,
2161        ///Timestamp when the job started. (e.g.
2162        /// '2025-12-24T18:50:20.5281314+01:00')
2163        #[serde(rename = "startTime")]
2164        pub start_time: ::std::string::String,
2165        ///True if the job completed successfully.
2166        pub success: bool,
2167    }
2168
2169    impl ::std::convert::From<&JobStatusResponse> for JobStatusResponse {
2170        fn from(value: &JobStatusResponse) -> Self {
2171            value.clone()
2172        }
2173    }
2174
2175    ///`MountListmountsResponse`
2176    ///
2177    /// <details><summary>JSON schema</summary>
2178    ///
2179    /// ```json
2180    ///{
2181    ///  "type": "object",
2182    ///  "required": [
2183    ///    "mountPoints"
2184    ///  ],
2185    ///  "properties": {
2186    ///    "mountPoints": {
2187    ///      "type": "array",
2188    ///      "items": {
2189    ///        "type": "object",
2190    ///        "required": [
2191    ///          "Fs",
2192    ///          "MountPoint",
2193    ///          "MountedOn"
2194    ///        ],
2195    ///        "properties": {
2196    ///          "Fs": {
2197    ///            "type": "string"
2198    ///          },
2199    ///          "MountPoint": {
2200    ///            "type": "string"
2201    ///          },
2202    ///          "MountedOn": {
2203    ///            "type": "string",
2204    ///            "format": "date-time"
2205    ///          }
2206    ///        },
2207    ///        "additionalProperties": false
2208    ///      }
2209    ///    }
2210    ///  }
2211    ///}
2212    /// ```
2213    /// </details>
2214    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2215    pub struct MountListmountsResponse {
2216        #[serde(rename = "mountPoints")]
2217        pub mount_points: ::std::vec::Vec<MountListmountsResponseMountPointsItem>,
2218    }
2219
2220    impl ::std::convert::From<&MountListmountsResponse> for MountListmountsResponse {
2221        fn from(value: &MountListmountsResponse) -> Self {
2222            value.clone()
2223        }
2224    }
2225
2226    ///`MountListmountsResponseMountPointsItem`
2227    ///
2228    /// <details><summary>JSON schema</summary>
2229    ///
2230    /// ```json
2231    ///{
2232    ///  "type": "object",
2233    ///  "required": [
2234    ///    "Fs",
2235    ///    "MountPoint",
2236    ///    "MountedOn"
2237    ///  ],
2238    ///  "properties": {
2239    ///    "Fs": {
2240    ///      "type": "string"
2241    ///    },
2242    ///    "MountPoint": {
2243    ///      "type": "string"
2244    ///    },
2245    ///    "MountedOn": {
2246    ///      "type": "string",
2247    ///      "format": "date-time"
2248    ///    }
2249    ///  },
2250    ///  "additionalProperties": false
2251    ///}
2252    /// ```
2253    /// </details>
2254    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2255    #[serde(deny_unknown_fields)]
2256    pub struct MountListmountsResponseMountPointsItem {
2257        #[serde(rename = "Fs")]
2258        pub fs: ::std::string::String,
2259        #[serde(rename = "MountPoint")]
2260        pub mount_point: ::std::string::String,
2261        #[serde(rename = "MountedOn")]
2262        pub mounted_on: ::chrono::DateTime<::chrono::offset::Utc>,
2263    }
2264
2265    impl ::std::convert::From<&MountListmountsResponseMountPointsItem>
2266        for MountListmountsResponseMountPointsItem
2267    {
2268        fn from(value: &MountListmountsResponseMountPointsItem) -> Self {
2269            value.clone()
2270        }
2271    }
2272
2273    ///`MountTypesResponse`
2274    ///
2275    /// <details><summary>JSON schema</summary>
2276    ///
2277    /// ```json
2278    ///{
2279    ///  "type": "object",
2280    ///  "required": [
2281    ///    "mountTypes"
2282    ///  ],
2283    ///  "properties": {
2284    ///    "mountTypes": {
2285    ///      "type": "array",
2286    ///      "items": {
2287    ///        "type": "string"
2288    ///      }
2289    ///    }
2290    ///  }
2291    ///}
2292    /// ```
2293    /// </details>
2294    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2295    pub struct MountTypesResponse {
2296        #[serde(rename = "mountTypes")]
2297        pub mount_types: ::std::vec::Vec<::std::string::String>,
2298    }
2299
2300    impl ::std::convert::From<&MountTypesResponse> for MountTypesResponse {
2301        fn from(value: &MountTypesResponse) -> Self {
2302            value.clone()
2303        }
2304    }
2305
2306    ///`OperationsAboutResponse`
2307    ///
2308    /// <details><summary>JSON schema</summary>
2309    ///
2310    /// ```json
2311    ///{
2312    ///  "type": "object",
2313    ///  "required": [
2314    ///    "free",
2315    ///    "total",
2316    ///    "used"
2317    ///  ],
2318    ///  "properties": {
2319    ///    "free": {
2320    ///      "type": "number"
2321    ///    },
2322    ///    "objects": {
2323    ///      "type": "number"
2324    ///    },
2325    ///    "other": {
2326    ///      "type": "number"
2327    ///    },
2328    ///    "total": {
2329    ///      "type": "number"
2330    ///    },
2331    ///    "trashed": {
2332    ///      "type": "number"
2333    ///    },
2334    ///    "used": {
2335    ///      "type": "number"
2336    ///    }
2337    ///  }
2338    ///}
2339    /// ```
2340    /// </details>
2341    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2342    pub struct OperationsAboutResponse {
2343        pub free: f64,
2344        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2345        pub objects: ::std::option::Option<f64>,
2346        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2347        pub other: ::std::option::Option<f64>,
2348        pub total: f64,
2349        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2350        pub trashed: ::std::option::Option<f64>,
2351        pub used: f64,
2352    }
2353
2354    impl ::std::convert::From<&OperationsAboutResponse> for OperationsAboutResponse {
2355        fn from(value: &OperationsAboutResponse) -> Self {
2356            value.clone()
2357        }
2358    }
2359
2360    ///`OperationsCheckResponse`
2361    ///
2362    /// <details><summary>JSON schema</summary>
2363    ///
2364    /// ```json
2365    ///{
2366    ///  "type": "object",
2367    ///  "required": [
2368    ///    "status",
2369    ///    "success"
2370    ///  ],
2371    ///  "properties": {
2372    ///    "combined": {
2373    ///      "description": "Combined summary lines when `combined=true` is
2374    /// requested.",
2375    ///      "type": "array",
2376    ///      "items": {
2377    ///        "type": "string"
2378    ///      }
2379    ///    },
2380    ///    "differ": {
2381    ///      "description": "Files that differed between source and
2382    /// destination.",
2383    ///      "type": "array",
2384    ///      "items": {
2385    ///        "type": "string"
2386    ///      }
2387    ///    },
2388    ///    "error": {
2389    ///      "description": "Entries that produced errors during the check.",
2390    ///      "type": "array",
2391    ///      "items": {
2392    ///        "type": "string"
2393    ///      }
2394    ///    },
2395    ///    "hashType": {
2396    ///      "description": "Hash algorithm used for comparisons when
2397    /// applicable.",
2398    ///      "type": "string"
2399    ///    },
2400    ///    "match": {
2401    ///      "description": "Files that matched on both sides.",
2402    ///      "type": "array",
2403    ///      "items": {
2404    ///        "type": "string"
2405    ///      }
2406    ///    },
2407    ///    "missingOnDst": {
2408    ///      "description": "Files present on the source but missing from the
2409    /// destination.",
2410    ///      "type": "array",
2411    ///      "items": {
2412    ///        "type": "string"
2413    ///      }
2414    ///    },
2415    ///    "missingOnSrc": {
2416    ///      "description": "Files present on the destination but missing from
2417    /// the source.",
2418    ///      "type": "array",
2419    ///      "items": {
2420    ///        "type": "string"
2421    ///      }
2422    ///    },
2423    ///    "status": {
2424    ///      "description": "Human readable status string.",
2425    ///      "type": "string"
2426    ///    },
2427    ///    "success": {
2428    ///      "description": "True when the check completes without differences
2429    /// or errors.",
2430    ///      "type": "boolean"
2431    ///    }
2432    ///  }
2433    ///}
2434    /// ```
2435    /// </details>
2436    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2437    pub struct OperationsCheckResponse {
2438        ///Combined summary lines when `combined=true` is requested.
2439        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2440        pub combined: ::std::vec::Vec<::std::string::String>,
2441        ///Files that differed between source and destination.
2442        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2443        pub differ: ::std::vec::Vec<::std::string::String>,
2444        ///Entries that produced errors during the check.
2445        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2446        pub error: ::std::vec::Vec<::std::string::String>,
2447        ///Hash algorithm used for comparisons when applicable.
2448        #[serde(
2449            rename = "hashType",
2450            default,
2451            skip_serializing_if = "::std::option::Option::is_none"
2452        )]
2453        pub hash_type: ::std::option::Option<::std::string::String>,
2454        ///Files that matched on both sides.
2455        #[serde(
2456            rename = "match",
2457            default,
2458            skip_serializing_if = "::std::vec::Vec::is_empty"
2459        )]
2460        pub match_: ::std::vec::Vec<::std::string::String>,
2461        ///Files present on the source but missing from the destination.
2462        #[serde(
2463            rename = "missingOnDst",
2464            default,
2465            skip_serializing_if = "::std::vec::Vec::is_empty"
2466        )]
2467        pub missing_on_dst: ::std::vec::Vec<::std::string::String>,
2468        ///Files present on the destination but missing from the source.
2469        #[serde(
2470            rename = "missingOnSrc",
2471            default,
2472            skip_serializing_if = "::std::vec::Vec::is_empty"
2473        )]
2474        pub missing_on_src: ::std::vec::Vec<::std::string::String>,
2475        ///Human readable status string.
2476        pub status: ::std::string::String,
2477        ///True when the check completes without differences or errors.
2478        pub success: bool,
2479    }
2480
2481    impl ::std::convert::From<&OperationsCheckResponse> for OperationsCheckResponse {
2482        fn from(value: &OperationsCheckResponse) -> Self {
2483            value.clone()
2484        }
2485    }
2486
2487    ///`OperationsFsinfoResponse`
2488    ///
2489    /// <details><summary>JSON schema</summary>
2490    ///
2491    /// ```json
2492    ///{
2493    ///  "type": "object",
2494    ///  "required": [
2495    ///    "Features",
2496    ///    "Hashes",
2497    ///    "Name",
2498    ///    "Precision",
2499    ///    "Root",
2500    ///    "String"
2501    ///  ],
2502    ///  "properties": {
2503    ///    "Features": {
2504    ///      "type": "object",
2505    ///      "additionalProperties": {
2506    ///        "type": "boolean"
2507    ///      }
2508    ///    },
2509    ///    "Hashes": {
2510    ///      "type": "array",
2511    ///      "items": {
2512    ///        "type": "string"
2513    ///      }
2514    ///    },
2515    ///    "MetadataInfo": {
2516    ///      "type": [
2517    ///        "object",
2518    ///        "null"
2519    ///      ],
2520    ///      "additionalProperties": true
2521    ///    },
2522    ///    "Name": {
2523    ///      "type": "string"
2524    ///    },
2525    ///    "Precision": {
2526    ///      "type": "number"
2527    ///    },
2528    ///    "Root": {
2529    ///      "type": "string"
2530    ///    },
2531    ///    "String": {
2532    ///      "type": "string"
2533    ///    }
2534    ///  }
2535    ///}
2536    /// ```
2537    /// </details>
2538    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2539    pub struct OperationsFsinfoResponse {
2540        #[serde(rename = "Features")]
2541        pub features: ::std::collections::HashMap<::std::string::String, bool>,
2542        #[serde(rename = "Hashes")]
2543        pub hashes: ::std::vec::Vec<::std::string::String>,
2544        #[serde(
2545            rename = "MetadataInfo",
2546            default,
2547            skip_serializing_if = "::std::option::Option::is_none"
2548        )]
2549        pub metadata_info:
2550            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
2551        #[serde(rename = "Name")]
2552        pub name: ::std::string::String,
2553        #[serde(rename = "Precision")]
2554        pub precision: f64,
2555        #[serde(rename = "Root")]
2556        pub root: ::std::string::String,
2557        #[serde(rename = "String")]
2558        pub string: ::std::string::String,
2559    }
2560
2561    impl ::std::convert::From<&OperationsFsinfoResponse> for OperationsFsinfoResponse {
2562        fn from(value: &OperationsFsinfoResponse) -> Self {
2563            value.clone()
2564        }
2565    }
2566
2567    ///`OperationsHashsumResponse`
2568    ///
2569    /// <details><summary>JSON schema</summary>
2570    ///
2571    /// ```json
2572    ///{
2573    ///  "type": "object",
2574    ///  "required": [
2575    ///    "hashType",
2576    ///    "hashsum"
2577    ///  ],
2578    ///  "properties": {
2579    ///    "hashType": {
2580    ///      "type": "string"
2581    ///    },
2582    ///    "hashsum": {
2583    ///      "type": "array",
2584    ///      "items": {
2585    ///        "type": "string"
2586    ///      }
2587    ///    }
2588    ///  }
2589    ///}
2590    /// ```
2591    /// </details>
2592    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2593    pub struct OperationsHashsumResponse {
2594        #[serde(rename = "hashType")]
2595        pub hash_type: ::std::string::String,
2596        pub hashsum: ::std::vec::Vec<::std::string::String>,
2597    }
2598
2599    impl ::std::convert::From<&OperationsHashsumResponse> for OperationsHashsumResponse {
2600        fn from(value: &OperationsHashsumResponse) -> Self {
2601            value.clone()
2602        }
2603    }
2604
2605    ///`OperationsListResponse`
2606    ///
2607    /// <details><summary>JSON schema</summary>
2608    ///
2609    /// ```json
2610    ///{
2611    ///  "type": "object",
2612    ///  "required": [
2613    ///    "list"
2614    ///  ],
2615    ///  "properties": {
2616    ///    "list": {
2617    ///      "description": "Array of entries equivalent to the items returned
2618    /// by `rclone lsjson`.",
2619    ///      "type": "array",
2620    ///      "items": {
2621    ///        "type": "object",
2622    ///        "required": [
2623    ///          "IsDir",
2624    ///          "Name",
2625    ///          "Path"
2626    ///        ],
2627    ///        "properties": {
2628    ///          "Encrypted": {
2629    ///            "description": "Encrypted entry name when using crypt
2630    /// remotes.",
2631    ///            "type": "string"
2632    ///          },
2633    ///          "EncryptedPath": {
2634    ///            "description": "Encrypted path when using crypt remotes.",
2635    ///            "type": "string"
2636    ///          },
2637    ///          "Hashes": {
2638    ///            "description": "Hash digests keyed by algorithm when
2639    /// requested.",
2640    ///            "type": "object",
2641    ///            "additionalProperties": {
2642    ///              "type": "string"
2643    ///            }
2644    ///          },
2645    ///          "ID": {
2646    ///            "description": "Backend-specific identifier when provided.",
2647    ///            "type": "string"
2648    ///          },
2649    ///          "IsBucket": {
2650    ///            "description": "True for bucket/root entries on bucket-based
2651    /// remotes.",
2652    ///            "type": "boolean"
2653    ///          },
2654    ///          "IsDir": {
2655    ///            "description": "True if the entry represents a directory.",
2656    ///            "type": "boolean"
2657    ///          },
2658    ///          "Metadata": {
2659    ///            "description": "Backend-provided metadata map.",
2660    ///            "type": "object",
2661    ///            "additionalProperties": {}
2662    ///          },
2663    ///          "MimeType": {
2664    ///            "description": "MIME type where available.",
2665    ///            "type": "string"
2666    ///          },
2667    ///          "ModTime": {
2668    ///            "description": "Modification timestamp in RFC3339 format.",
2669    ///            "type": "string"
2670    ///          },
2671    ///          "Name": {
2672    ///            "description": "Base name of the entry.",
2673    ///            "type": "string"
2674    ///          },
2675    ///          "OrigID": {
2676    ///            "description": "Original backend identifier when recorded.",
2677    ///            "type": "string"
2678    ///          },
2679    ///          "Path": {
2680    ///            "description": "Path relative to the requested remote root.",
2681    ///            "type": "string"
2682    ///          },
2683    ///          "Size": {
2684    ///            "description": "Object size in bytes.",
2685    ///            "type": "number"
2686    ///          },
2687    ///          "Tier": {
2688    ///            "description": "Storage class or tier, if supplied by the
2689    /// backend.",
2690    ///            "type": "string"
2691    ///          }
2692    ///        }
2693    ///      }
2694    ///    }
2695    ///  }
2696    ///}
2697    /// ```
2698    /// </details>
2699    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2700    pub struct OperationsListResponse {
2701        ///Array of entries equivalent to the items returned by `rclone
2702        /// lsjson`.
2703        pub list: ::std::vec::Vec<OperationsListResponseListItem>,
2704    }
2705
2706    impl ::std::convert::From<&OperationsListResponse> for OperationsListResponse {
2707        fn from(value: &OperationsListResponse) -> Self {
2708            value.clone()
2709        }
2710    }
2711
2712    ///`OperationsListResponseListItem`
2713    ///
2714    /// <details><summary>JSON schema</summary>
2715    ///
2716    /// ```json
2717    ///{
2718    ///  "type": "object",
2719    ///  "required": [
2720    ///    "IsDir",
2721    ///    "Name",
2722    ///    "Path"
2723    ///  ],
2724    ///  "properties": {
2725    ///    "Encrypted": {
2726    ///      "description": "Encrypted entry name when using crypt remotes.",
2727    ///      "type": "string"
2728    ///    },
2729    ///    "EncryptedPath": {
2730    ///      "description": "Encrypted path when using crypt remotes.",
2731    ///      "type": "string"
2732    ///    },
2733    ///    "Hashes": {
2734    ///      "description": "Hash digests keyed by algorithm when requested.",
2735    ///      "type": "object",
2736    ///      "additionalProperties": {
2737    ///        "type": "string"
2738    ///      }
2739    ///    },
2740    ///    "ID": {
2741    ///      "description": "Backend-specific identifier when provided.",
2742    ///      "type": "string"
2743    ///    },
2744    ///    "IsBucket": {
2745    ///      "description": "True for bucket/root entries on bucket-based
2746    /// remotes.",
2747    ///      "type": "boolean"
2748    ///    },
2749    ///    "IsDir": {
2750    ///      "description": "True if the entry represents a directory.",
2751    ///      "type": "boolean"
2752    ///    },
2753    ///    "Metadata": {
2754    ///      "description": "Backend-provided metadata map.",
2755    ///      "type": "object",
2756    ///      "additionalProperties": {}
2757    ///    },
2758    ///    "MimeType": {
2759    ///      "description": "MIME type where available.",
2760    ///      "type": "string"
2761    ///    },
2762    ///    "ModTime": {
2763    ///      "description": "Modification timestamp in RFC3339 format.",
2764    ///      "type": "string"
2765    ///    },
2766    ///    "Name": {
2767    ///      "description": "Base name of the entry.",
2768    ///      "type": "string"
2769    ///    },
2770    ///    "OrigID": {
2771    ///      "description": "Original backend identifier when recorded.",
2772    ///      "type": "string"
2773    ///    },
2774    ///    "Path": {
2775    ///      "description": "Path relative to the requested remote root.",
2776    ///      "type": "string"
2777    ///    },
2778    ///    "Size": {
2779    ///      "description": "Object size in bytes.",
2780    ///      "type": "number"
2781    ///    },
2782    ///    "Tier": {
2783    ///      "description": "Storage class or tier, if supplied by the
2784    /// backend.",
2785    ///      "type": "string"
2786    ///    }
2787    ///  }
2788    ///}
2789    /// ```
2790    /// </details>
2791    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2792    pub struct OperationsListResponseListItem {
2793        ///Encrypted entry name when using crypt remotes.
2794        #[serde(
2795            rename = "Encrypted",
2796            default,
2797            skip_serializing_if = "::std::option::Option::is_none"
2798        )]
2799        pub encrypted: ::std::option::Option<::std::string::String>,
2800        ///Encrypted path when using crypt remotes.
2801        #[serde(
2802            rename = "EncryptedPath",
2803            default,
2804            skip_serializing_if = "::std::option::Option::is_none"
2805        )]
2806        pub encrypted_path: ::std::option::Option<::std::string::String>,
2807        ///Hash digests keyed by algorithm when requested.
2808        #[serde(
2809            rename = "Hashes",
2810            default,
2811            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
2812        )]
2813        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
2814        ///Backend-specific identifier when provided.
2815        #[serde(
2816            rename = "ID",
2817            default,
2818            skip_serializing_if = "::std::option::Option::is_none"
2819        )]
2820        pub id: ::std::option::Option<::std::string::String>,
2821        ///True for bucket/root entries on bucket-based remotes.
2822        #[serde(
2823            rename = "IsBucket",
2824            default,
2825            skip_serializing_if = "::std::option::Option::is_none"
2826        )]
2827        pub is_bucket: ::std::option::Option<bool>,
2828        ///True if the entry represents a directory.
2829        #[serde(rename = "IsDir")]
2830        pub is_dir: bool,
2831        ///Backend-provided metadata map.
2832        #[serde(
2833            rename = "Metadata",
2834            default,
2835            skip_serializing_if = "::serde_json::Map::is_empty"
2836        )]
2837        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
2838        ///MIME type where available.
2839        #[serde(
2840            rename = "MimeType",
2841            default,
2842            skip_serializing_if = "::std::option::Option::is_none"
2843        )]
2844        pub mime_type: ::std::option::Option<::std::string::String>,
2845        ///Modification timestamp in RFC3339 format.
2846        #[serde(
2847            rename = "ModTime",
2848            default,
2849            skip_serializing_if = "::std::option::Option::is_none"
2850        )]
2851        pub mod_time: ::std::option::Option<::std::string::String>,
2852        ///Base name of the entry.
2853        #[serde(rename = "Name")]
2854        pub name: ::std::string::String,
2855        ///Original backend identifier when recorded.
2856        #[serde(
2857            rename = "OrigID",
2858            default,
2859            skip_serializing_if = "::std::option::Option::is_none"
2860        )]
2861        pub orig_id: ::std::option::Option<::std::string::String>,
2862        ///Path relative to the requested remote root.
2863        #[serde(rename = "Path")]
2864        pub path: ::std::string::String,
2865        #[serde(
2866            rename = "Size",
2867            default,
2868            skip_serializing_if = "::std::option::Option::is_none"
2869        )]
2870        pub size: ::std::option::Option<f64>,
2871        ///Storage class or tier, if supplied by the backend.
2872        #[serde(
2873            rename = "Tier",
2874            default,
2875            skip_serializing_if = "::std::option::Option::is_none"
2876        )]
2877        pub tier: ::std::option::Option<::std::string::String>,
2878    }
2879
2880    impl ::std::convert::From<&OperationsListResponseListItem> for OperationsListResponseListItem {
2881        fn from(value: &OperationsListResponseListItem) -> Self {
2882            value.clone()
2883        }
2884    }
2885
2886    ///`OperationsPubliclinkResponse`
2887    ///
2888    /// <details><summary>JSON schema</summary>
2889    ///
2890    /// ```json
2891    ///{
2892    ///  "type": "object",
2893    ///  "required": [
2894    ///    "url"
2895    ///  ],
2896    ///  "properties": {
2897    ///    "url": {
2898    ///      "type": "string",
2899    ///      "format": "uri"
2900    ///    }
2901    ///  }
2902    ///}
2903    /// ```
2904    /// </details>
2905    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2906    pub struct OperationsPubliclinkResponse {
2907        pub url: ::std::string::String,
2908    }
2909
2910    impl ::std::convert::From<&OperationsPubliclinkResponse> for OperationsPubliclinkResponse {
2911        fn from(value: &OperationsPubliclinkResponse) -> Self {
2912            value.clone()
2913        }
2914    }
2915
2916    ///`OperationsSizeResponse`
2917    ///
2918    /// <details><summary>JSON schema</summary>
2919    ///
2920    /// ```json
2921    ///{
2922    ///  "type": "object",
2923    ///  "required": [
2924    ///    "bytes",
2925    ///    "count",
2926    ///    "sizeless"
2927    ///  ],
2928    ///  "properties": {
2929    ///    "bytes": {
2930    ///      "type": "number"
2931    ///    },
2932    ///    "count": {
2933    ///      "type": "integer"
2934    ///    },
2935    ///    "sizeless": {
2936    ///      "type": "integer"
2937    ///    }
2938    ///  }
2939    ///}
2940    /// ```
2941    /// </details>
2942    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2943    pub struct OperationsSizeResponse {
2944        pub bytes: f64,
2945        pub count: i64,
2946        pub sizeless: i64,
2947    }
2948
2949    impl ::std::convert::From<&OperationsSizeResponse> for OperationsSizeResponse {
2950        fn from(value: &OperationsSizeResponse) -> Self {
2951            value.clone()
2952        }
2953    }
2954
2955    ///`OperationsStatResponse`
2956    ///
2957    /// <details><summary>JSON schema</summary>
2958    ///
2959    /// ```json
2960    ///{
2961    ///  "type": "object",
2962    ///  "required": [
2963    ///    "IsDir",
2964    ///    "MimeType",
2965    ///    "ModTime",
2966    ///    "Name",
2967    ///    "Path",
2968    ///    "Size"
2969    ///  ],
2970    ///  "properties": {
2971    ///    "Encrypted": {
2972    ///      "description": "Encrypted entry name when using crypt remotes.",
2973    ///      "type": "string"
2974    ///    },
2975    ///    "EncryptedPath": {
2976    ///      "description": "Encrypted path when using crypt remotes.",
2977    ///      "type": "string"
2978    ///    },
2979    ///    "Hashes": {
2980    ///      "description": "Hash digests keyed by algorithm when requested.",
2981    ///      "type": "object",
2982    ///      "additionalProperties": {
2983    ///        "type": "string"
2984    ///      }
2985    ///    },
2986    ///    "ID": {
2987    ///      "description": "Backend-specific identifier when provided.",
2988    ///      "type": "string"
2989    ///    },
2990    ///    "IsBucket": {
2991    ///      "description": "True for bucket/root entries on bucket-based
2992    /// remotes.",
2993    ///      "type": "boolean"
2994    ///    },
2995    ///    "IsDir": {
2996    ///      "description": "True if the entry is a directory.",
2997    ///      "type": "boolean"
2998    ///    },
2999    ///    "Metadata": {
3000    ///      "description": "Backend-provided metadata map.",
3001    ///      "type": "object",
3002    ///      "additionalProperties": {}
3003    ///    },
3004    ///    "MimeType": {
3005    ///      "description": "MIME type where available.",
3006    ///      "type": "string"
3007    ///    },
3008    ///    "ModTime": {
3009    ///      "description": "Modification timestamp in RFC3339 format.",
3010    ///      "type": "string"
3011    ///    },
3012    ///    "Name": {
3013    ///      "description": "Base name of the entry.",
3014    ///      "type": "string"
3015    ///    },
3016    ///    "OrigID": {
3017    ///      "description": "Original backend identifier when recorded.",
3018    ///      "type": "string"
3019    ///    },
3020    ///    "Path": {
3021    ///      "description": "Path relative to the remote root.",
3022    ///      "type": "string"
3023    ///    },
3024    ///    "Size": {
3025    ///      "description": "Object size in bytes.",
3026    ///      "type": "number"
3027    ///    },
3028    ///    "Tier": {
3029    ///      "description": "Storage class or tier, if supplied by the
3030    /// backend.",
3031    ///      "type": "string"
3032    ///    }
3033    ///  }
3034    ///}
3035    /// ```
3036    /// </details>
3037    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3038    pub struct OperationsStatResponse {
3039        ///Encrypted entry name when using crypt remotes.
3040        #[serde(
3041            rename = "Encrypted",
3042            default,
3043            skip_serializing_if = "::std::option::Option::is_none"
3044        )]
3045        pub encrypted: ::std::option::Option<::std::string::String>,
3046        ///Encrypted path when using crypt remotes.
3047        #[serde(
3048            rename = "EncryptedPath",
3049            default,
3050            skip_serializing_if = "::std::option::Option::is_none"
3051        )]
3052        pub encrypted_path: ::std::option::Option<::std::string::String>,
3053        ///Hash digests keyed by algorithm when requested.
3054        #[serde(
3055            rename = "Hashes",
3056            default,
3057            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
3058        )]
3059        pub hashes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3060        ///Backend-specific identifier when provided.
3061        #[serde(
3062            rename = "ID",
3063            default,
3064            skip_serializing_if = "::std::option::Option::is_none"
3065        )]
3066        pub id: ::std::option::Option<::std::string::String>,
3067        ///True for bucket/root entries on bucket-based remotes.
3068        #[serde(
3069            rename = "IsBucket",
3070            default,
3071            skip_serializing_if = "::std::option::Option::is_none"
3072        )]
3073        pub is_bucket: ::std::option::Option<bool>,
3074        ///True if the entry is a directory.
3075        #[serde(rename = "IsDir")]
3076        pub is_dir: bool,
3077        ///Backend-provided metadata map.
3078        #[serde(
3079            rename = "Metadata",
3080            default,
3081            skip_serializing_if = "::serde_json::Map::is_empty"
3082        )]
3083        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3084        ///MIME type where available.
3085        #[serde(rename = "MimeType")]
3086        pub mime_type: ::std::string::String,
3087        ///Modification timestamp in RFC3339 format.
3088        #[serde(rename = "ModTime")]
3089        pub mod_time: ::std::string::String,
3090        ///Base name of the entry.
3091        #[serde(rename = "Name")]
3092        pub name: ::std::string::String,
3093        ///Original backend identifier when recorded.
3094        #[serde(
3095            rename = "OrigID",
3096            default,
3097            skip_serializing_if = "::std::option::Option::is_none"
3098        )]
3099        pub orig_id: ::std::option::Option<::std::string::String>,
3100        ///Path relative to the remote root.
3101        #[serde(rename = "Path")]
3102        pub path: ::std::string::String,
3103        #[serde(rename = "Size")]
3104        pub size: f64,
3105        ///Storage class or tier, if supplied by the backend.
3106        #[serde(
3107            rename = "Tier",
3108            default,
3109            skip_serializing_if = "::std::option::Option::is_none"
3110        )]
3111        pub tier: ::std::option::Option<::std::string::String>,
3112    }
3113
3114    impl ::std::convert::From<&OperationsStatResponse> for OperationsStatResponse {
3115        fn from(value: &OperationsStatResponse) -> Self {
3116            value.clone()
3117        }
3118    }
3119
3120    ///`OptionsBlocksResponse`
3121    ///
3122    /// <details><summary>JSON schema</summary>
3123    ///
3124    /// ```json
3125    ///{
3126    ///  "type": "object",
3127    ///  "required": [
3128    ///    "options"
3129    ///  ],
3130    ///  "properties": {
3131    ///    "options": {
3132    ///      "type": "array",
3133    ///      "items": {
3134    ///        "type": "string"
3135    ///      }
3136    ///    }
3137    ///  }
3138    ///}
3139    /// ```
3140    /// </details>
3141    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3142    pub struct OptionsBlocksResponse {
3143        pub options: ::std::vec::Vec<::std::string::String>,
3144    }
3145
3146    impl ::std::convert::From<&OptionsBlocksResponse> for OptionsBlocksResponse {
3147        fn from(value: &OptionsBlocksResponse) -> Self {
3148            value.clone()
3149        }
3150    }
3151
3152    ///`OptionsGetResponse`
3153    ///
3154    /// <details><summary>JSON schema</summary>
3155    ///
3156    /// ```json
3157    ///{
3158    ///  "type": "object",
3159    ///  "required": [
3160    ///    "dlna",
3161    ///    "filter",
3162    ///    "ftp",
3163    ///    "http",
3164    ///    "log",
3165    ///    "main",
3166    ///    "mount",
3167    ///    "nfs",
3168    ///    "proxy",
3169    ///    "rc",
3170    ///    "restic",
3171    ///    "s3",
3172    ///    "sftp",
3173    ///    "vfs",
3174    ///    "webdav"
3175    ///  ],
3176    ///  "properties": {
3177    ///    "dlna": {
3178    ///      "type": "object",
3179    ///      "additionalProperties": true
3180    ///    },
3181    ///    "filter": {
3182    ///      "type": "object",
3183    ///      "additionalProperties": true
3184    ///    },
3185    ///    "ftp": {
3186    ///      "type": "object",
3187    ///      "additionalProperties": true
3188    ///    },
3189    ///    "http": {
3190    ///      "type": "object",
3191    ///      "additionalProperties": true
3192    ///    },
3193    ///    "log": {
3194    ///      "type": "object",
3195    ///      "additionalProperties": true
3196    ///    },
3197    ///    "main": {
3198    ///      "type": "object",
3199    ///      "additionalProperties": true
3200    ///    },
3201    ///    "mount": {
3202    ///      "type": "object",
3203    ///      "additionalProperties": true
3204    ///    },
3205    ///    "nfs": {
3206    ///      "type": "object",
3207    ///      "additionalProperties": true
3208    ///    },
3209    ///    "proxy": {
3210    ///      "type": "object",
3211    ///      "additionalProperties": true
3212    ///    },
3213    ///    "rc": {
3214    ///      "type": "object",
3215    ///      "additionalProperties": true
3216    ///    },
3217    ///    "restic": {
3218    ///      "type": "object",
3219    ///      "additionalProperties": true
3220    ///    },
3221    ///    "s3": {
3222    ///      "type": "object",
3223    ///      "additionalProperties": true
3224    ///    },
3225    ///    "sftp": {
3226    ///      "type": "object",
3227    ///      "additionalProperties": true
3228    ///    },
3229    ///    "vfs": {
3230    ///      "type": "object",
3231    ///      "additionalProperties": true
3232    ///    },
3233    ///    "webdav": {
3234    ///      "type": "object",
3235    ///      "additionalProperties": true
3236    ///    }
3237    ///  },
3238    ///  "additionalProperties": true
3239    ///}
3240    /// ```
3241    /// </details>
3242    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3243    pub struct OptionsGetResponse {
3244        pub dlna: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3245        pub filter: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3246        pub ftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3247        pub http: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3248        pub log: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3249        pub main: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3250        pub mount: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3251        pub nfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3252        pub proxy: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3253        pub rc: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3254        pub restic: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3255        pub s3: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3256        pub sftp: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3257        pub vfs: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3258        pub webdav: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
3259    }
3260
3261    impl ::std::convert::From<&OptionsGetResponse> for OptionsGetResponse {
3262        fn from(value: &OptionsGetResponse) -> Self {
3263            value.clone()
3264        }
3265    }
3266
3267    ///`OptionsInfoOption`
3268    ///
3269    /// <details><summary>JSON schema</summary>
3270    ///
3271    /// ```json
3272    ///{
3273    ///  "type": "object",
3274    ///  "required": [
3275    ///    "Advanced",
3276    ///    "Default",
3277    ///    "DefaultStr",
3278    ///    "Exclusive",
3279    ///    "FieldName",
3280    ///    "Help",
3281    ///    "Hide",
3282    ///    "IsPassword",
3283    ///    "Name",
3284    ///    "NoPrefix",
3285    ///    "Required",
3286    ///    "Sensitive",
3287    ///    "Type",
3288    ///    "Value",
3289    ///    "ValueStr"
3290    ///  ],
3291    ///  "properties": {
3292    ///    "Advanced": {
3293    ///      "type": "boolean"
3294    ///    },
3295    ///    "Default": {
3296    ///      "description": "Default value for this option.",
3297    ///      "anyOf": [
3298    ///        {
3299    ///          "type": "array",
3300    ///          "items": {
3301    ///            "type": "string"
3302    ///          }
3303    ///        },
3304    ///        {
3305    ///          "type": "boolean"
3306    ///        },
3307    ///        {
3308    ///          "type": "number"
3309    ///        },
3310    ///        {
3311    ///          "type": "string"
3312    ///        },
3313    ///        {
3314    ///          "type": "object",
3315    ///          "required": [
3316    ///            "Valid",
3317    ///            "Value"
3318    ///          ],
3319    ///          "properties": {
3320    ///            "Valid": {
3321    ///              "type": "boolean"
3322    ///            },
3323    ///            "Value": {
3324    ///              "type": "boolean"
3325    ///            }
3326    ///          },
3327    ///          "additionalProperties": false
3328    ///        }
3329    ///      ]
3330    ///    },
3331    ///    "DefaultStr": {
3332    ///      "type": "string"
3333    ///    },
3334    ///    "Examples": {
3335    ///      "type": "array",
3336    ///      "items": {
3337    ///        "$ref": "#/components/schemas/OptionsInfoOptionExample"
3338    ///      }
3339    ///    },
3340    ///    "Exclusive": {
3341    ///      "type": "boolean"
3342    ///    },
3343    ///    "FieldName": {
3344    ///      "type": "string"
3345    ///    },
3346    ///    "Groups": {
3347    ///      "type": "string"
3348    ///    },
3349    ///    "Help": {
3350    ///      "type": "string"
3351    ///    },
3352    ///    "Hide": {
3353    ///      "type": "integer"
3354    ///    },
3355    ///    "IsPassword": {
3356    ///      "type": "boolean"
3357    ///    },
3358    ///    "Name": {
3359    ///      "type": "string"
3360    ///    },
3361    ///    "NoPrefix": {
3362    ///      "type": "boolean"
3363    ///    },
3364    ///    "Required": {
3365    ///      "type": "boolean"
3366    ///    },
3367    ///    "Sensitive": {
3368    ///      "type": "boolean"
3369    ///    },
3370    ///    "ShortOpt": {
3371    ///      "type": "string"
3372    ///    },
3373    ///    "Type": {
3374    ///      "type": "string"
3375    ///    },
3376    ///    "Value": {
3377    ///      "oneOf": [
3378    ///        {
3379    ///          "type": "null"
3380    ///        },
3381    ///        {
3382    ///          "anyOf": [
3383    ///            {
3384    ///              "type": "boolean"
3385    ///            },
3386    ///            {
3387    ///              "type": "number"
3388    ///            }
3389    ///          ]
3390    ///        }
3391    ///      ]
3392    ///    },
3393    ///    "ValueStr": {
3394    ///      "type": "string"
3395    ///    }
3396    ///  },
3397    ///  "additionalProperties": true
3398    ///}
3399    /// ```
3400    /// </details>
3401    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3402    pub struct OptionsInfoOption {
3403        #[serde(rename = "Advanced")]
3404        pub advanced: bool,
3405        ///Default value for this option.
3406        #[serde(rename = "Default")]
3407        pub default: OptionsInfoOptionDefault,
3408        #[serde(rename = "DefaultStr")]
3409        pub default_str: ::std::string::String,
3410        #[serde(
3411            rename = "Examples",
3412            default,
3413            skip_serializing_if = "::std::vec::Vec::is_empty"
3414        )]
3415        pub examples: ::std::vec::Vec<OptionsInfoOptionExample>,
3416        #[serde(rename = "Exclusive")]
3417        pub exclusive: bool,
3418        #[serde(rename = "FieldName")]
3419        pub field_name: ::std::string::String,
3420        #[serde(
3421            rename = "Groups",
3422            default,
3423            skip_serializing_if = "::std::option::Option::is_none"
3424        )]
3425        pub groups: ::std::option::Option<::std::string::String>,
3426        #[serde(rename = "Help")]
3427        pub help: ::std::string::String,
3428        #[serde(rename = "Hide")]
3429        pub hide: i64,
3430        #[serde(rename = "IsPassword")]
3431        pub is_password: bool,
3432        #[serde(rename = "Name")]
3433        pub name: ::std::string::String,
3434        #[serde(rename = "NoPrefix")]
3435        pub no_prefix: bool,
3436        #[serde(rename = "Required")]
3437        pub required: bool,
3438        #[serde(rename = "Sensitive")]
3439        pub sensitive: bool,
3440        #[serde(
3441            rename = "ShortOpt",
3442            default,
3443            skip_serializing_if = "::std::option::Option::is_none"
3444        )]
3445        pub short_opt: ::std::option::Option<::std::string::String>,
3446        #[serde(rename = "Type")]
3447        pub type_: ::std::string::String,
3448        #[serde(rename = "Value")]
3449        pub value: ::std::option::Option<OptionsInfoOptionValue>,
3450        #[serde(rename = "ValueStr")]
3451        pub value_str: ::std::string::String,
3452    }
3453
3454    impl ::std::convert::From<&OptionsInfoOption> for OptionsInfoOption {
3455        fn from(value: &OptionsInfoOption) -> Self {
3456            value.clone()
3457        }
3458    }
3459
3460    ///Default value for this option.
3461    ///
3462    /// <details><summary>JSON schema</summary>
3463    ///
3464    /// ```json
3465    ///{
3466    ///  "description": "Default value for this option.",
3467    ///  "anyOf": [
3468    ///    {
3469    ///      "type": "array",
3470    ///      "items": {
3471    ///        "type": "string"
3472    ///      }
3473    ///    },
3474    ///    {
3475    ///      "type": "boolean"
3476    ///    },
3477    ///    {
3478    ///      "type": "number"
3479    ///    },
3480    ///    {
3481    ///      "type": "string"
3482    ///    },
3483    ///    {
3484    ///      "type": "object",
3485    ///      "required": [
3486    ///        "Valid",
3487    ///        "Value"
3488    ///      ],
3489    ///      "properties": {
3490    ///        "Valid": {
3491    ///          "type": "boolean"
3492    ///        },
3493    ///        "Value": {
3494    ///          "type": "boolean"
3495    ///        }
3496    ///      },
3497    ///      "additionalProperties": false
3498    ///    }
3499    ///  ]
3500    ///}
3501    /// ```
3502    /// </details>
3503    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3504    #[serde(untagged, deny_unknown_fields)]
3505    pub enum OptionsInfoOptionDefault {
3506        Variant0(::std::vec::Vec<::std::string::String>),
3507        Variant1(bool),
3508        Variant2(f64),
3509        Variant3(::std::string::String),
3510        Variant4 {
3511            #[serde(rename = "Valid")]
3512            valid: bool,
3513            #[serde(rename = "Value")]
3514            value: bool,
3515        },
3516    }
3517
3518    impl ::std::convert::From<&Self> for OptionsInfoOptionDefault {
3519        fn from(value: &OptionsInfoOptionDefault) -> Self {
3520            value.clone()
3521        }
3522    }
3523
3524    impl ::std::convert::From<::std::vec::Vec<::std::string::String>> for OptionsInfoOptionDefault {
3525        fn from(value: ::std::vec::Vec<::std::string::String>) -> Self {
3526            Self::Variant0(value)
3527        }
3528    }
3529
3530    impl ::std::convert::From<bool> for OptionsInfoOptionDefault {
3531        fn from(value: bool) -> Self {
3532            Self::Variant1(value)
3533        }
3534    }
3535
3536    impl ::std::convert::From<f64> for OptionsInfoOptionDefault {
3537        fn from(value: f64) -> Self {
3538            Self::Variant2(value)
3539        }
3540    }
3541
3542    ///`OptionsInfoOptionExample`
3543    ///
3544    /// <details><summary>JSON schema</summary>
3545    ///
3546    /// ```json
3547    ///{
3548    ///  "type": "object",
3549    ///  "required": [
3550    ///    "Help",
3551    ///    "Value"
3552    ///  ],
3553    ///  "properties": {
3554    ///    "Help": {
3555    ///      "type": "string"
3556    ///    },
3557    ///    "Value": {
3558    ///      "type": "string"
3559    ///    }
3560    ///  },
3561    ///  "additionalProperties": true
3562    ///}
3563    /// ```
3564    /// </details>
3565    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3566    pub struct OptionsInfoOptionExample {
3567        #[serde(rename = "Help")]
3568        pub help: ::std::string::String,
3569        #[serde(rename = "Value")]
3570        pub value: ::std::string::String,
3571    }
3572
3573    impl ::std::convert::From<&OptionsInfoOptionExample> for OptionsInfoOptionExample {
3574        fn from(value: &OptionsInfoOptionExample) -> Self {
3575            value.clone()
3576        }
3577    }
3578
3579    ///`OptionsInfoOptionValue`
3580    ///
3581    /// <details><summary>JSON schema</summary>
3582    ///
3583    /// ```json
3584    ///{
3585    ///  "anyOf": [
3586    ///    {
3587    ///      "type": "boolean"
3588    ///    },
3589    ///    {
3590    ///      "type": "number"
3591    ///    }
3592    ///  ]
3593    ///}
3594    /// ```
3595    /// </details>
3596    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3597    #[serde(untagged)]
3598    pub enum OptionsInfoOptionValue {
3599        Variant0(bool),
3600        Variant1(f64),
3601    }
3602
3603    impl ::std::convert::From<&Self> for OptionsInfoOptionValue {
3604        fn from(value: &OptionsInfoOptionValue) -> Self {
3605            value.clone()
3606        }
3607    }
3608
3609    impl ::std::str::FromStr for OptionsInfoOptionValue {
3610        type Err = self::error::ConversionError;
3611        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3612            if let Ok(v) = value.parse() {
3613                Ok(Self::Variant0(v))
3614            } else if let Ok(v) = value.parse() {
3615                Ok(Self::Variant1(v))
3616            } else {
3617                Err("string conversion failed for all variants".into())
3618            }
3619        }
3620    }
3621
3622    impl ::std::convert::TryFrom<&str> for OptionsInfoOptionValue {
3623        type Error = self::error::ConversionError;
3624        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3625            value.parse()
3626        }
3627    }
3628
3629    impl ::std::convert::TryFrom<&::std::string::String> for OptionsInfoOptionValue {
3630        type Error = self::error::ConversionError;
3631        fn try_from(
3632            value: &::std::string::String,
3633        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3634            value.parse()
3635        }
3636    }
3637
3638    impl ::std::convert::TryFrom<::std::string::String> for OptionsInfoOptionValue {
3639        type Error = self::error::ConversionError;
3640        fn try_from(
3641            value: ::std::string::String,
3642        ) -> ::std::result::Result<Self, self::error::ConversionError> {
3643            value.parse()
3644        }
3645    }
3646
3647    impl ::std::fmt::Display for OptionsInfoOptionValue {
3648        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3649            match self {
3650                Self::Variant0(x) => x.fmt(f),
3651                Self::Variant1(x) => x.fmt(f),
3652            }
3653        }
3654    }
3655
3656    impl ::std::convert::From<bool> for OptionsInfoOptionValue {
3657        fn from(value: bool) -> Self {
3658            Self::Variant0(value)
3659        }
3660    }
3661
3662    impl ::std::convert::From<f64> for OptionsInfoOptionValue {
3663        fn from(value: f64) -> Self {
3664            Self::Variant1(value)
3665        }
3666    }
3667
3668    ///`OptionsInfoResponse`
3669    ///
3670    /// <details><summary>JSON schema</summary>
3671    ///
3672    /// ```json
3673    ///{
3674    ///  "type": "object",
3675    ///  "required": [
3676    ///    "dlna",
3677    ///    "filter",
3678    ///    "ftp",
3679    ///    "http",
3680    ///    "log",
3681    ///    "main",
3682    ///    "mount",
3683    ///    "nfs",
3684    ///    "proxy",
3685    ///    "rc",
3686    ///    "restic",
3687    ///    "s3",
3688    ///    "sftp",
3689    ///    "vfs",
3690    ///    "webdav"
3691    ///  ],
3692    ///  "properties": {
3693    ///    "dlna": {
3694    ///      "type": "array",
3695    ///      "items": {
3696    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3697    ///      }
3698    ///    },
3699    ///    "filter": {
3700    ///      "type": "array",
3701    ///      "items": {
3702    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3703    ///      }
3704    ///    },
3705    ///    "ftp": {
3706    ///      "type": "array",
3707    ///      "items": {
3708    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3709    ///      }
3710    ///    },
3711    ///    "http": {
3712    ///      "type": "array",
3713    ///      "items": {
3714    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3715    ///      }
3716    ///    },
3717    ///    "log": {
3718    ///      "type": "array",
3719    ///      "items": {
3720    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3721    ///      }
3722    ///    },
3723    ///    "main": {
3724    ///      "type": "array",
3725    ///      "items": {
3726    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3727    ///      }
3728    ///    },
3729    ///    "mount": {
3730    ///      "type": "array",
3731    ///      "items": {
3732    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3733    ///      }
3734    ///    },
3735    ///    "nfs": {
3736    ///      "type": "array",
3737    ///      "items": {
3738    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3739    ///      }
3740    ///    },
3741    ///    "proxy": {
3742    ///      "type": "array",
3743    ///      "items": {
3744    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3745    ///      }
3746    ///    },
3747    ///    "rc": {
3748    ///      "type": "array",
3749    ///      "items": {
3750    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3751    ///      }
3752    ///    },
3753    ///    "restic": {
3754    ///      "type": "array",
3755    ///      "items": {
3756    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3757    ///      }
3758    ///    },
3759    ///    "s3": {
3760    ///      "type": "array",
3761    ///      "items": {
3762    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3763    ///      }
3764    ///    },
3765    ///    "sftp": {
3766    ///      "type": "array",
3767    ///      "items": {
3768    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3769    ///      }
3770    ///    },
3771    ///    "vfs": {
3772    ///      "type": "array",
3773    ///      "items": {
3774    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3775    ///      }
3776    ///    },
3777    ///    "webdav": {
3778    ///      "type": "array",
3779    ///      "items": {
3780    ///        "$ref": "#/components/schemas/OptionsInfoOption"
3781    ///      }
3782    ///    }
3783    ///  },
3784    ///  "additionalProperties": {
3785    ///    "type": "array",
3786    ///    "items": {
3787    ///      "$ref": "#/components/schemas/OptionsInfoOption"
3788    ///    }
3789    ///  }
3790    ///}
3791    /// ```
3792    /// </details>
3793    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3794    pub struct OptionsInfoResponse {
3795        pub dlna: ::std::vec::Vec<OptionsInfoOption>,
3796        pub filter: ::std::vec::Vec<OptionsInfoOption>,
3797        pub ftp: ::std::vec::Vec<OptionsInfoOption>,
3798        pub http: ::std::vec::Vec<OptionsInfoOption>,
3799        pub log: ::std::vec::Vec<OptionsInfoOption>,
3800        pub main: ::std::vec::Vec<OptionsInfoOption>,
3801        pub mount: ::std::vec::Vec<OptionsInfoOption>,
3802        pub nfs: ::std::vec::Vec<OptionsInfoOption>,
3803        pub proxy: ::std::vec::Vec<OptionsInfoOption>,
3804        pub rc: ::std::vec::Vec<OptionsInfoOption>,
3805        pub restic: ::std::vec::Vec<OptionsInfoOption>,
3806        pub s3: ::std::vec::Vec<OptionsInfoOption>,
3807        pub sftp: ::std::vec::Vec<OptionsInfoOption>,
3808        pub vfs: ::std::vec::Vec<OptionsInfoOption>,
3809        pub webdav: ::std::vec::Vec<OptionsInfoOption>,
3810        #[serde(flatten)]
3811        pub extra:
3812            ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<OptionsInfoOption>>,
3813    }
3814
3815    impl ::std::convert::From<&OptionsInfoResponse> for OptionsInfoResponse {
3816        fn from(value: &OptionsInfoResponse) -> Self {
3817            value.clone()
3818        }
3819    }
3820
3821    ///`OptionsLocalResponse`
3822    ///
3823    /// <details><summary>JSON schema</summary>
3824    ///
3825    /// ```json
3826    ///{
3827    ///  "type": "object",
3828    ///  "required": [
3829    ///    "config",
3830    ///    "filter"
3831    ///  ],
3832    ///  "properties": {
3833    ///    "config": {
3834    ///      "type": "object",
3835    ///      "required": [
3836    ///        "AskPassword",
3837    ///        "AutoConfirm",
3838    ///        "BackupDir",
3839    ///        "BindAddr",
3840    ///        "BufferSize",
3841    ///        "BwLimit",
3842    ///        "BwLimitFile",
3843    ///        "CaCert",
3844    ///        "CheckFirst",
3845    ///        "CheckSum",
3846    ///        "Checkers",
3847    ///        "ClientCert",
3848    ///        "ClientKey",
3849    ///        "CompareDest",
3850    ///        "ConnectTimeout",
3851    ///        "Cookie",
3852    ///        "CopyDest",
3853    ///        "CutoffMode",
3854    ///        "DataRateUnit",
3855    ///        "DefaultTime",
3856    ///        "DeleteMode",
3857    ///        "DisableFeatures",
3858    ///        "DisableHTTP2",
3859    ///        "DisableHTTPKeepAlives",
3860    ///        "DownloadHeaders",
3861    ///        "DryRun",
3862    ///        "Dump",
3863    ///        "ErrorOnNoTransfer",
3864    ///        "ExpectContinueTimeout",
3865    ///        "FixCase",
3866    ///        "FsCacheExpireDuration",
3867    ///        "FsCacheExpireInterval",
3868    ///        "Headers",
3869    ///        "HumanReadable",
3870    ///        "IgnoreCaseSync",
3871    ///        "IgnoreChecksum",
3872    ///        "IgnoreErrors",
3873    ///        "IgnoreExisting",
3874    ///        "IgnoreSize",
3875    ///        "IgnoreTimes",
3876    ///        "Immutable",
3877    ///        "Inplace",
3878    ///        "InsecureSkipVerify",
3879    ///        "Interactive",
3880    ///        "KvLockTime",
3881    ///        "Links",
3882    ///        "LogLevel",
3883    ///        "LowLevelRetries",
3884    ///        "MaxBacklog",
3885    ///        "MaxBufferMemory",
3886    ///        "MaxDelete",
3887    ///        "MaxDeleteSize",
3888    ///        "MaxDepth",
3889    ///        "MaxDuration",
3890    ///        "MaxStatsGroups",
3891    ///        "MaxTransfer",
3892    ///        "Metadata",
3893    ///        "MetadataMapper",
3894    ///        "MetadataSet",
3895    ///        "ModifyWindow",
3896    ///        "MultiThreadChunkSize",
3897    ///        "MultiThreadCutoff",
3898    ///        "MultiThreadSet",
3899    ///        "MultiThreadStreams",
3900    ///        "MultiThreadWriteBufferSize",
3901    ///        "NoCheckDest",
3902    ///        "NoConsole",
3903    ///        "NoGzip",
3904    ///        "NoTraverse",
3905    ///        "NoUnicodeNormalization",
3906    ///        "NoUpdateDirModTime",
3907    ///        "NoUpdateModTime",
3908    ///        "OrderBy",
3909    ///        "PartialSuffix",
3910    ///        "PasswordCommand",
3911    ///        "Progress",
3912    ///        "ProgressTerminalTitle",
3913    ///        "RefreshTimes",
3914    ///        "Retries",
3915    ///        "RetriesInterval",
3916    ///        "ServerSideAcrossConfigs",
3917    ///        "SizeOnly",
3918    ///        "StatsFileNameLength",
3919    ///        "StatsLogLevel",
3920    ///        "StatsOneLine",
3921    ///        "StatsOneLineDate",
3922    ///        "StatsOneLineDateFormat",
3923    ///        "StreamingUploadCutoff",
3924    ///        "Suffix",
3925    ///        "SuffixKeepExtension",
3926    ///        "TPSLimit",
3927    ///        "TPSLimitBurst",
3928    ///        "TerminalColorMode",
3929    ///        "Timeout",
3930    ///        "TrackRenames",
3931    ///        "TrackRenamesStrategy",
3932    ///        "TrafficClass",
3933    ///        "Transfers",
3934    ///        "UpdateOlder",
3935    ///        "UploadHeaders",
3936    ///        "UseJSONLog",
3937    ///        "UseListR",
3938    ///        "UseMmap",
3939    ///        "UseServerModTime",
3940    ///        "UserAgent"
3941    ///      ],
3942    ///      "properties": {
3943    ///        "AskPassword": {
3944    ///          "type": "boolean"
3945    ///        },
3946    ///        "AutoConfirm": {
3947    ///          "type": "boolean"
3948    ///        },
3949    ///        "BackupDir": {
3950    ///          "type": "string"
3951    ///        },
3952    ///        "BindAddr": {
3953    ///          "type": "string"
3954    ///        },
3955    ///        "BufferSize": {
3956    ///          "type": "number"
3957    ///        },
3958    ///        "BwLimit": {
3959    ///          "type": "string"
3960    ///        },
3961    ///        "BwLimitFile": {
3962    ///          "type": "string"
3963    ///        },
3964    ///        "CaCert": {
3965    ///          "type": "array",
3966    ///          "items": {
3967    ///            "type": "string"
3968    ///          }
3969    ///        },
3970    ///        "CheckFirst": {
3971    ///          "type": "boolean"
3972    ///        },
3973    ///        "CheckSum": {
3974    ///          "type": "boolean"
3975    ///        },
3976    ///        "Checkers": {
3977    ///          "type": "number"
3978    ///        },
3979    ///        "ClientCert": {
3980    ///          "type": "string"
3981    ///        },
3982    ///        "ClientKey": {
3983    ///          "type": "string"
3984    ///        },
3985    ///        "CompareDest": {
3986    ///          "type": "array",
3987    ///          "items": {
3988    ///            "type": "string"
3989    ///          }
3990    ///        },
3991    ///        "ConnectTimeout": {
3992    ///          "type": "number"
3993    ///        },
3994    ///        "Cookie": {
3995    ///          "type": "boolean"
3996    ///        },
3997    ///        "CopyDest": {
3998    ///          "type": "array",
3999    ///          "items": {
4000    ///            "type": "string"
4001    ///          }
4002    ///        },
4003    ///        "CutoffMode": {
4004    ///          "type": "string"
4005    ///        },
4006    ///        "DataRateUnit": {
4007    ///          "type": "string"
4008    ///        },
4009    ///        "DefaultTime": {
4010    ///          "type": "string"
4011    ///        },
4012    ///        "DeleteMode": {
4013    ///          "type": "number"
4014    ///        },
4015    ///        "DisableFeatures": {
4016    ///          "type": [
4017    ///            "string",
4018    ///            "null"
4019    ///          ],
4020    ///          "format": "null"
4021    ///        },
4022    ///        "DisableHTTP2": {
4023    ///          "type": "boolean"
4024    ///        },
4025    ///        "DisableHTTPKeepAlives": {
4026    ///          "type": "boolean"
4027    ///        },
4028    ///        "DownloadHeaders": {
4029    ///          "type": [
4030    ///            "string",
4031    ///            "null"
4032    ///          ],
4033    ///          "format": "null"
4034    ///        },
4035    ///        "DryRun": {
4036    ///          "type": "boolean"
4037    ///        },
4038    ///        "Dump": {
4039    ///          "type": "string"
4040    ///        },
4041    ///        "ErrorOnNoTransfer": {
4042    ///          "type": "boolean"
4043    ///        },
4044    ///        "ExpectContinueTimeout": {
4045    ///          "type": "number"
4046    ///        },
4047    ///        "FixCase": {
4048    ///          "type": "boolean"
4049    ///        },
4050    ///        "FsCacheExpireDuration": {
4051    ///          "type": "number"
4052    ///        },
4053    ///        "FsCacheExpireInterval": {
4054    ///          "type": "number"
4055    ///        },
4056    ///        "Headers": {
4057    ///          "type": [
4058    ///            "string",
4059    ///            "null"
4060    ///          ],
4061    ///          "format": "null"
4062    ///        },
4063    ///        "HumanReadable": {
4064    ///          "type": "boolean"
4065    ///        },
4066    ///        "IgnoreCaseSync": {
4067    ///          "type": "boolean"
4068    ///        },
4069    ///        "IgnoreChecksum": {
4070    ///          "type": "boolean"
4071    ///        },
4072    ///        "IgnoreErrors": {
4073    ///          "type": "boolean"
4074    ///        },
4075    ///        "IgnoreExisting": {
4076    ///          "type": "boolean"
4077    ///        },
4078    ///        "IgnoreSize": {
4079    ///          "type": "boolean"
4080    ///        },
4081    ///        "IgnoreTimes": {
4082    ///          "type": "boolean"
4083    ///        },
4084    ///        "Immutable": {
4085    ///          "type": "boolean"
4086    ///        },
4087    ///        "Inplace": {
4088    ///          "type": "boolean"
4089    ///        },
4090    ///        "InsecureSkipVerify": {
4091    ///          "type": "boolean"
4092    ///        },
4093    ///        "Interactive": {
4094    ///          "type": "boolean"
4095    ///        },
4096    ///        "KvLockTime": {
4097    ///          "type": "number"
4098    ///        },
4099    ///        "Links": {
4100    ///          "type": "boolean"
4101    ///        },
4102    ///        "LogLevel": {
4103    ///          "type": "string"
4104    ///        },
4105    ///        "LowLevelRetries": {
4106    ///          "type": "number"
4107    ///        },
4108    ///        "MaxBacklog": {
4109    ///          "type": "number"
4110    ///        },
4111    ///        "MaxBufferMemory": {
4112    ///          "type": "number"
4113    ///        },
4114    ///        "MaxDelete": {
4115    ///          "type": "number"
4116    ///        },
4117    ///        "MaxDeleteSize": {
4118    ///          "type": "number"
4119    ///        },
4120    ///        "MaxDepth": {
4121    ///          "type": "number"
4122    ///        },
4123    ///        "MaxDuration": {
4124    ///          "type": "number"
4125    ///        },
4126    ///        "MaxStatsGroups": {
4127    ///          "type": "number"
4128    ///        },
4129    ///        "MaxTransfer": {
4130    ///          "type": "number"
4131    ///        },
4132    ///        "Metadata": {
4133    ///          "type": "boolean"
4134    ///        },
4135    ///        "MetadataMapper": {
4136    ///          "type": [
4137    ///            "string",
4138    ///            "null"
4139    ///          ],
4140    ///          "format": "null"
4141    ///        },
4142    ///        "MetadataSet": {
4143    ///          "type": [
4144    ///            "string",
4145    ///            "null"
4146    ///          ],
4147    ///          "format": "null"
4148    ///        },
4149    ///        "ModifyWindow": {
4150    ///          "type": "number"
4151    ///        },
4152    ///        "MultiThreadChunkSize": {
4153    ///          "type": "number"
4154    ///        },
4155    ///        "MultiThreadCutoff": {
4156    ///          "type": "number"
4157    ///        },
4158    ///        "MultiThreadSet": {
4159    ///          "type": "boolean"
4160    ///        },
4161    ///        "MultiThreadStreams": {
4162    ///          "type": "number"
4163    ///        },
4164    ///        "MultiThreadWriteBufferSize": {
4165    ///          "type": "number"
4166    ///        },
4167    ///        "NoCheckDest": {
4168    ///          "type": "boolean"
4169    ///        },
4170    ///        "NoConsole": {
4171    ///          "type": "boolean"
4172    ///        },
4173    ///        "NoGzip": {
4174    ///          "type": "boolean"
4175    ///        },
4176    ///        "NoTraverse": {
4177    ///          "type": "boolean"
4178    ///        },
4179    ///        "NoUnicodeNormalization": {
4180    ///          "type": "boolean"
4181    ///        },
4182    ///        "NoUpdateDirModTime": {
4183    ///          "type": "boolean"
4184    ///        },
4185    ///        "NoUpdateModTime": {
4186    ///          "type": "boolean"
4187    ///        },
4188    ///        "OrderBy": {
4189    ///          "type": "string"
4190    ///        },
4191    ///        "PartialSuffix": {
4192    ///          "type": "string"
4193    ///        },
4194    ///        "PasswordCommand": {
4195    ///          "type": [
4196    ///            "string",
4197    ///            "null"
4198    ///          ],
4199    ///          "format": "null"
4200    ///        },
4201    ///        "Progress": {
4202    ///          "type": "boolean"
4203    ///        },
4204    ///        "ProgressTerminalTitle": {
4205    ///          "type": "boolean"
4206    ///        },
4207    ///        "RefreshTimes": {
4208    ///          "type": "boolean"
4209    ///        },
4210    ///        "Retries": {
4211    ///          "type": "number"
4212    ///        },
4213    ///        "RetriesInterval": {
4214    ///          "type": "number"
4215    ///        },
4216    ///        "ServerSideAcrossConfigs": {
4217    ///          "type": "boolean"
4218    ///        },
4219    ///        "SizeOnly": {
4220    ///          "type": "boolean"
4221    ///        },
4222    ///        "StatsFileNameLength": {
4223    ///          "type": "number"
4224    ///        },
4225    ///        "StatsLogLevel": {
4226    ///          "type": "string"
4227    ///        },
4228    ///        "StatsOneLine": {
4229    ///          "type": "boolean"
4230    ///        },
4231    ///        "StatsOneLineDate": {
4232    ///          "type": "boolean"
4233    ///        },
4234    ///        "StatsOneLineDateFormat": {
4235    ///          "type": "string"
4236    ///        },
4237    ///        "StreamingUploadCutoff": {
4238    ///          "type": "number"
4239    ///        },
4240    ///        "Suffix": {
4241    ///          "type": "string"
4242    ///        },
4243    ///        "SuffixKeepExtension": {
4244    ///          "type": "boolean"
4245    ///        },
4246    ///        "TPSLimit": {
4247    ///          "type": "number"
4248    ///        },
4249    ///        "TPSLimitBurst": {
4250    ///          "type": "number"
4251    ///        },
4252    ///        "TerminalColorMode": {
4253    ///          "type": "string"
4254    ///        },
4255    ///        "Timeout": {
4256    ///          "type": "number"
4257    ///        },
4258    ///        "TrackRenames": {
4259    ///          "type": "boolean"
4260    ///        },
4261    ///        "TrackRenamesStrategy": {
4262    ///          "type": "string"
4263    ///        },
4264    ///        "TrafficClass": {
4265    ///          "type": "number"
4266    ///        },
4267    ///        "Transfers": {
4268    ///          "type": "number"
4269    ///        },
4270    ///        "UpdateOlder": {
4271    ///          "type": "boolean"
4272    ///        },
4273    ///        "UploadHeaders": {
4274    ///          "type": [
4275    ///            "string",
4276    ///            "null"
4277    ///          ],
4278    ///          "format": "null"
4279    ///        },
4280    ///        "UseJSONLog": {
4281    ///          "type": "boolean"
4282    ///        },
4283    ///        "UseListR": {
4284    ///          "type": "boolean"
4285    ///        },
4286    ///        "UseMmap": {
4287    ///          "type": "boolean"
4288    ///        },
4289    ///        "UseServerModTime": {
4290    ///          "type": "boolean"
4291    ///        },
4292    ///        "UserAgent": {
4293    ///          "type": "string"
4294    ///        }
4295    ///      }
4296    ///    },
4297    ///    "filter": {
4298    ///      "type": "object",
4299    ///      "required": [
4300    ///        "DeleteExcluded",
4301    ///        "ExcludeFile",
4302    ///        "ExcludeFrom",
4303    ///        "ExcludeRule",
4304    ///        "FilesFrom",
4305    ///        "FilesFromRaw",
4306    ///        "FilterFrom",
4307    ///        "FilterRule",
4308    ///        "HashFilter",
4309    ///        "IgnoreCase",
4310    ///        "IncludeFrom",
4311    ///        "IncludeRule",
4312    ///        "MaxAge",
4313    ///        "MaxSize",
4314    ///        "MetaRules",
4315    ///        "MinAge",
4316    ///        "MinSize"
4317    ///      ],
4318    ///      "properties": {
4319    ///        "DeleteExcluded": {
4320    ///          "type": "boolean"
4321    ///        },
4322    ///        "ExcludeFile": {
4323    ///          "type": "array",
4324    ///          "items": {
4325    ///            "type": "string"
4326    ///          }
4327    ///        },
4328    ///        "ExcludeFrom": {
4329    ///          "type": "array",
4330    ///          "items": {
4331    ///            "type": "string"
4332    ///          }
4333    ///        },
4334    ///        "ExcludeRule": {
4335    ///          "type": "array",
4336    ///          "items": {
4337    ///            "type": "string"
4338    ///          }
4339    ///        },
4340    ///        "FilesFrom": {
4341    ///          "type": "array",
4342    ///          "items": {
4343    ///            "type": "string"
4344    ///          }
4345    ///        },
4346    ///        "FilesFromRaw": {
4347    ///          "type": "array",
4348    ///          "items": {
4349    ///            "type": "string"
4350    ///          }
4351    ///        },
4352    ///        "FilterFrom": {
4353    ///          "type": "array",
4354    ///          "items": {
4355    ///            "type": "string"
4356    ///          }
4357    ///        },
4358    ///        "FilterRule": {
4359    ///          "type": "array",
4360    ///          "items": {
4361    ///            "type": "string"
4362    ///          }
4363    ///        },
4364    ///        "HashFilter": {
4365    ///          "type": "string"
4366    ///        },
4367    ///        "IgnoreCase": {
4368    ///          "type": "boolean"
4369    ///        },
4370    ///        "IncludeFrom": {
4371    ///          "type": "array",
4372    ///          "items": {
4373    ///            "type": "string"
4374    ///          }
4375    ///        },
4376    ///        "IncludeRule": {
4377    ///          "type": "array",
4378    ///          "items": {
4379    ///            "type": "string"
4380    ///          }
4381    ///        },
4382    ///        "MaxAge": {
4383    ///          "type": "number"
4384    ///        },
4385    ///        "MaxSize": {
4386    ///          "type": "number"
4387    ///        },
4388    ///        "MetaRules": {
4389    ///          "type": "object",
4390    ///          "required": [
4391    ///            "ExcludeFrom",
4392    ///            "ExcludeRule",
4393    ///            "FilterFrom",
4394    ///            "FilterRule",
4395    ///            "IncludeFrom",
4396    ///            "IncludeRule"
4397    ///          ],
4398    ///          "properties": {
4399    ///            "ExcludeFrom": {
4400    ///              "type": "array",
4401    ///              "items": {
4402    ///                "type": "string"
4403    ///              }
4404    ///            },
4405    ///            "ExcludeRule": {
4406    ///              "type": "array",
4407    ///              "items": {
4408    ///                "type": "string"
4409    ///              }
4410    ///            },
4411    ///            "FilterFrom": {
4412    ///              "type": "array",
4413    ///              "items": {
4414    ///                "type": "string"
4415    ///              }
4416    ///            },
4417    ///            "FilterRule": {
4418    ///              "type": "array",
4419    ///              "items": {
4420    ///                "type": "string"
4421    ///              }
4422    ///            },
4423    ///            "IncludeFrom": {
4424    ///              "type": "array",
4425    ///              "items": {
4426    ///                "type": "string"
4427    ///              }
4428    ///            },
4429    ///            "IncludeRule": {
4430    ///              "type": "array",
4431    ///              "items": {
4432    ///                "type": "string"
4433    ///              }
4434    ///            }
4435    ///          }
4436    ///        },
4437    ///        "MinAge": {
4438    ///          "type": "number"
4439    ///        },
4440    ///        "MinSize": {
4441    ///          "type": "number"
4442    ///        }
4443    ///      }
4444    ///    }
4445    ///  }
4446    ///}
4447    /// ```
4448    /// </details>
4449    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4450    pub struct OptionsLocalResponse {
4451        pub config: OptionsLocalResponseConfig,
4452        pub filter: OptionsLocalResponseFilter,
4453    }
4454
4455    impl ::std::convert::From<&OptionsLocalResponse> for OptionsLocalResponse {
4456        fn from(value: &OptionsLocalResponse) -> Self {
4457            value.clone()
4458        }
4459    }
4460
4461    ///`OptionsLocalResponseConfig`
4462    ///
4463    /// <details><summary>JSON schema</summary>
4464    ///
4465    /// ```json
4466    ///{
4467    ///  "type": "object",
4468    ///  "required": [
4469    ///    "AskPassword",
4470    ///    "AutoConfirm",
4471    ///    "BackupDir",
4472    ///    "BindAddr",
4473    ///    "BufferSize",
4474    ///    "BwLimit",
4475    ///    "BwLimitFile",
4476    ///    "CaCert",
4477    ///    "CheckFirst",
4478    ///    "CheckSum",
4479    ///    "Checkers",
4480    ///    "ClientCert",
4481    ///    "ClientKey",
4482    ///    "CompareDest",
4483    ///    "ConnectTimeout",
4484    ///    "Cookie",
4485    ///    "CopyDest",
4486    ///    "CutoffMode",
4487    ///    "DataRateUnit",
4488    ///    "DefaultTime",
4489    ///    "DeleteMode",
4490    ///    "DisableFeatures",
4491    ///    "DisableHTTP2",
4492    ///    "DisableHTTPKeepAlives",
4493    ///    "DownloadHeaders",
4494    ///    "DryRun",
4495    ///    "Dump",
4496    ///    "ErrorOnNoTransfer",
4497    ///    "ExpectContinueTimeout",
4498    ///    "FixCase",
4499    ///    "FsCacheExpireDuration",
4500    ///    "FsCacheExpireInterval",
4501    ///    "Headers",
4502    ///    "HumanReadable",
4503    ///    "IgnoreCaseSync",
4504    ///    "IgnoreChecksum",
4505    ///    "IgnoreErrors",
4506    ///    "IgnoreExisting",
4507    ///    "IgnoreSize",
4508    ///    "IgnoreTimes",
4509    ///    "Immutable",
4510    ///    "Inplace",
4511    ///    "InsecureSkipVerify",
4512    ///    "Interactive",
4513    ///    "KvLockTime",
4514    ///    "Links",
4515    ///    "LogLevel",
4516    ///    "LowLevelRetries",
4517    ///    "MaxBacklog",
4518    ///    "MaxBufferMemory",
4519    ///    "MaxDelete",
4520    ///    "MaxDeleteSize",
4521    ///    "MaxDepth",
4522    ///    "MaxDuration",
4523    ///    "MaxStatsGroups",
4524    ///    "MaxTransfer",
4525    ///    "Metadata",
4526    ///    "MetadataMapper",
4527    ///    "MetadataSet",
4528    ///    "ModifyWindow",
4529    ///    "MultiThreadChunkSize",
4530    ///    "MultiThreadCutoff",
4531    ///    "MultiThreadSet",
4532    ///    "MultiThreadStreams",
4533    ///    "MultiThreadWriteBufferSize",
4534    ///    "NoCheckDest",
4535    ///    "NoConsole",
4536    ///    "NoGzip",
4537    ///    "NoTraverse",
4538    ///    "NoUnicodeNormalization",
4539    ///    "NoUpdateDirModTime",
4540    ///    "NoUpdateModTime",
4541    ///    "OrderBy",
4542    ///    "PartialSuffix",
4543    ///    "PasswordCommand",
4544    ///    "Progress",
4545    ///    "ProgressTerminalTitle",
4546    ///    "RefreshTimes",
4547    ///    "Retries",
4548    ///    "RetriesInterval",
4549    ///    "ServerSideAcrossConfigs",
4550    ///    "SizeOnly",
4551    ///    "StatsFileNameLength",
4552    ///    "StatsLogLevel",
4553    ///    "StatsOneLine",
4554    ///    "StatsOneLineDate",
4555    ///    "StatsOneLineDateFormat",
4556    ///    "StreamingUploadCutoff",
4557    ///    "Suffix",
4558    ///    "SuffixKeepExtension",
4559    ///    "TPSLimit",
4560    ///    "TPSLimitBurst",
4561    ///    "TerminalColorMode",
4562    ///    "Timeout",
4563    ///    "TrackRenames",
4564    ///    "TrackRenamesStrategy",
4565    ///    "TrafficClass",
4566    ///    "Transfers",
4567    ///    "UpdateOlder",
4568    ///    "UploadHeaders",
4569    ///    "UseJSONLog",
4570    ///    "UseListR",
4571    ///    "UseMmap",
4572    ///    "UseServerModTime",
4573    ///    "UserAgent"
4574    ///  ],
4575    ///  "properties": {
4576    ///    "AskPassword": {
4577    ///      "type": "boolean"
4578    ///    },
4579    ///    "AutoConfirm": {
4580    ///      "type": "boolean"
4581    ///    },
4582    ///    "BackupDir": {
4583    ///      "type": "string"
4584    ///    },
4585    ///    "BindAddr": {
4586    ///      "type": "string"
4587    ///    },
4588    ///    "BufferSize": {
4589    ///      "type": "number"
4590    ///    },
4591    ///    "BwLimit": {
4592    ///      "type": "string"
4593    ///    },
4594    ///    "BwLimitFile": {
4595    ///      "type": "string"
4596    ///    },
4597    ///    "CaCert": {
4598    ///      "type": "array",
4599    ///      "items": {
4600    ///        "type": "string"
4601    ///      }
4602    ///    },
4603    ///    "CheckFirst": {
4604    ///      "type": "boolean"
4605    ///    },
4606    ///    "CheckSum": {
4607    ///      "type": "boolean"
4608    ///    },
4609    ///    "Checkers": {
4610    ///      "type": "number"
4611    ///    },
4612    ///    "ClientCert": {
4613    ///      "type": "string"
4614    ///    },
4615    ///    "ClientKey": {
4616    ///      "type": "string"
4617    ///    },
4618    ///    "CompareDest": {
4619    ///      "type": "array",
4620    ///      "items": {
4621    ///        "type": "string"
4622    ///      }
4623    ///    },
4624    ///    "ConnectTimeout": {
4625    ///      "type": "number"
4626    ///    },
4627    ///    "Cookie": {
4628    ///      "type": "boolean"
4629    ///    },
4630    ///    "CopyDest": {
4631    ///      "type": "array",
4632    ///      "items": {
4633    ///        "type": "string"
4634    ///      }
4635    ///    },
4636    ///    "CutoffMode": {
4637    ///      "type": "string"
4638    ///    },
4639    ///    "DataRateUnit": {
4640    ///      "type": "string"
4641    ///    },
4642    ///    "DefaultTime": {
4643    ///      "type": "string"
4644    ///    },
4645    ///    "DeleteMode": {
4646    ///      "type": "number"
4647    ///    },
4648    ///    "DisableFeatures": {
4649    ///      "type": [
4650    ///        "string",
4651    ///        "null"
4652    ///      ],
4653    ///      "format": "null"
4654    ///    },
4655    ///    "DisableHTTP2": {
4656    ///      "type": "boolean"
4657    ///    },
4658    ///    "DisableHTTPKeepAlives": {
4659    ///      "type": "boolean"
4660    ///    },
4661    ///    "DownloadHeaders": {
4662    ///      "type": [
4663    ///        "string",
4664    ///        "null"
4665    ///      ],
4666    ///      "format": "null"
4667    ///    },
4668    ///    "DryRun": {
4669    ///      "type": "boolean"
4670    ///    },
4671    ///    "Dump": {
4672    ///      "type": "string"
4673    ///    },
4674    ///    "ErrorOnNoTransfer": {
4675    ///      "type": "boolean"
4676    ///    },
4677    ///    "ExpectContinueTimeout": {
4678    ///      "type": "number"
4679    ///    },
4680    ///    "FixCase": {
4681    ///      "type": "boolean"
4682    ///    },
4683    ///    "FsCacheExpireDuration": {
4684    ///      "type": "number"
4685    ///    },
4686    ///    "FsCacheExpireInterval": {
4687    ///      "type": "number"
4688    ///    },
4689    ///    "Headers": {
4690    ///      "type": [
4691    ///        "string",
4692    ///        "null"
4693    ///      ],
4694    ///      "format": "null"
4695    ///    },
4696    ///    "HumanReadable": {
4697    ///      "type": "boolean"
4698    ///    },
4699    ///    "IgnoreCaseSync": {
4700    ///      "type": "boolean"
4701    ///    },
4702    ///    "IgnoreChecksum": {
4703    ///      "type": "boolean"
4704    ///    },
4705    ///    "IgnoreErrors": {
4706    ///      "type": "boolean"
4707    ///    },
4708    ///    "IgnoreExisting": {
4709    ///      "type": "boolean"
4710    ///    },
4711    ///    "IgnoreSize": {
4712    ///      "type": "boolean"
4713    ///    },
4714    ///    "IgnoreTimes": {
4715    ///      "type": "boolean"
4716    ///    },
4717    ///    "Immutable": {
4718    ///      "type": "boolean"
4719    ///    },
4720    ///    "Inplace": {
4721    ///      "type": "boolean"
4722    ///    },
4723    ///    "InsecureSkipVerify": {
4724    ///      "type": "boolean"
4725    ///    },
4726    ///    "Interactive": {
4727    ///      "type": "boolean"
4728    ///    },
4729    ///    "KvLockTime": {
4730    ///      "type": "number"
4731    ///    },
4732    ///    "Links": {
4733    ///      "type": "boolean"
4734    ///    },
4735    ///    "LogLevel": {
4736    ///      "type": "string"
4737    ///    },
4738    ///    "LowLevelRetries": {
4739    ///      "type": "number"
4740    ///    },
4741    ///    "MaxBacklog": {
4742    ///      "type": "number"
4743    ///    },
4744    ///    "MaxBufferMemory": {
4745    ///      "type": "number"
4746    ///    },
4747    ///    "MaxDelete": {
4748    ///      "type": "number"
4749    ///    },
4750    ///    "MaxDeleteSize": {
4751    ///      "type": "number"
4752    ///    },
4753    ///    "MaxDepth": {
4754    ///      "type": "number"
4755    ///    },
4756    ///    "MaxDuration": {
4757    ///      "type": "number"
4758    ///    },
4759    ///    "MaxStatsGroups": {
4760    ///      "type": "number"
4761    ///    },
4762    ///    "MaxTransfer": {
4763    ///      "type": "number"
4764    ///    },
4765    ///    "Metadata": {
4766    ///      "type": "boolean"
4767    ///    },
4768    ///    "MetadataMapper": {
4769    ///      "type": [
4770    ///        "string",
4771    ///        "null"
4772    ///      ],
4773    ///      "format": "null"
4774    ///    },
4775    ///    "MetadataSet": {
4776    ///      "type": [
4777    ///        "string",
4778    ///        "null"
4779    ///      ],
4780    ///      "format": "null"
4781    ///    },
4782    ///    "ModifyWindow": {
4783    ///      "type": "number"
4784    ///    },
4785    ///    "MultiThreadChunkSize": {
4786    ///      "type": "number"
4787    ///    },
4788    ///    "MultiThreadCutoff": {
4789    ///      "type": "number"
4790    ///    },
4791    ///    "MultiThreadSet": {
4792    ///      "type": "boolean"
4793    ///    },
4794    ///    "MultiThreadStreams": {
4795    ///      "type": "number"
4796    ///    },
4797    ///    "MultiThreadWriteBufferSize": {
4798    ///      "type": "number"
4799    ///    },
4800    ///    "NoCheckDest": {
4801    ///      "type": "boolean"
4802    ///    },
4803    ///    "NoConsole": {
4804    ///      "type": "boolean"
4805    ///    },
4806    ///    "NoGzip": {
4807    ///      "type": "boolean"
4808    ///    },
4809    ///    "NoTraverse": {
4810    ///      "type": "boolean"
4811    ///    },
4812    ///    "NoUnicodeNormalization": {
4813    ///      "type": "boolean"
4814    ///    },
4815    ///    "NoUpdateDirModTime": {
4816    ///      "type": "boolean"
4817    ///    },
4818    ///    "NoUpdateModTime": {
4819    ///      "type": "boolean"
4820    ///    },
4821    ///    "OrderBy": {
4822    ///      "type": "string"
4823    ///    },
4824    ///    "PartialSuffix": {
4825    ///      "type": "string"
4826    ///    },
4827    ///    "PasswordCommand": {
4828    ///      "type": [
4829    ///        "string",
4830    ///        "null"
4831    ///      ],
4832    ///      "format": "null"
4833    ///    },
4834    ///    "Progress": {
4835    ///      "type": "boolean"
4836    ///    },
4837    ///    "ProgressTerminalTitle": {
4838    ///      "type": "boolean"
4839    ///    },
4840    ///    "RefreshTimes": {
4841    ///      "type": "boolean"
4842    ///    },
4843    ///    "Retries": {
4844    ///      "type": "number"
4845    ///    },
4846    ///    "RetriesInterval": {
4847    ///      "type": "number"
4848    ///    },
4849    ///    "ServerSideAcrossConfigs": {
4850    ///      "type": "boolean"
4851    ///    },
4852    ///    "SizeOnly": {
4853    ///      "type": "boolean"
4854    ///    },
4855    ///    "StatsFileNameLength": {
4856    ///      "type": "number"
4857    ///    },
4858    ///    "StatsLogLevel": {
4859    ///      "type": "string"
4860    ///    },
4861    ///    "StatsOneLine": {
4862    ///      "type": "boolean"
4863    ///    },
4864    ///    "StatsOneLineDate": {
4865    ///      "type": "boolean"
4866    ///    },
4867    ///    "StatsOneLineDateFormat": {
4868    ///      "type": "string"
4869    ///    },
4870    ///    "StreamingUploadCutoff": {
4871    ///      "type": "number"
4872    ///    },
4873    ///    "Suffix": {
4874    ///      "type": "string"
4875    ///    },
4876    ///    "SuffixKeepExtension": {
4877    ///      "type": "boolean"
4878    ///    },
4879    ///    "TPSLimit": {
4880    ///      "type": "number"
4881    ///    },
4882    ///    "TPSLimitBurst": {
4883    ///      "type": "number"
4884    ///    },
4885    ///    "TerminalColorMode": {
4886    ///      "type": "string"
4887    ///    },
4888    ///    "Timeout": {
4889    ///      "type": "number"
4890    ///    },
4891    ///    "TrackRenames": {
4892    ///      "type": "boolean"
4893    ///    },
4894    ///    "TrackRenamesStrategy": {
4895    ///      "type": "string"
4896    ///    },
4897    ///    "TrafficClass": {
4898    ///      "type": "number"
4899    ///    },
4900    ///    "Transfers": {
4901    ///      "type": "number"
4902    ///    },
4903    ///    "UpdateOlder": {
4904    ///      "type": "boolean"
4905    ///    },
4906    ///    "UploadHeaders": {
4907    ///      "type": [
4908    ///        "string",
4909    ///        "null"
4910    ///      ],
4911    ///      "format": "null"
4912    ///    },
4913    ///    "UseJSONLog": {
4914    ///      "type": "boolean"
4915    ///    },
4916    ///    "UseListR": {
4917    ///      "type": "boolean"
4918    ///    },
4919    ///    "UseMmap": {
4920    ///      "type": "boolean"
4921    ///    },
4922    ///    "UseServerModTime": {
4923    ///      "type": "boolean"
4924    ///    },
4925    ///    "UserAgent": {
4926    ///      "type": "string"
4927    ///    }
4928    ///  }
4929    ///}
4930    /// ```
4931    /// </details>
4932    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4933    pub struct OptionsLocalResponseConfig {
4934        #[serde(rename = "AskPassword")]
4935        pub ask_password: bool,
4936        #[serde(rename = "AutoConfirm")]
4937        pub auto_confirm: bool,
4938        #[serde(rename = "BackupDir")]
4939        pub backup_dir: ::std::string::String,
4940        #[serde(rename = "BindAddr")]
4941        pub bind_addr: ::std::string::String,
4942        #[serde(rename = "BufferSize")]
4943        pub buffer_size: f64,
4944        #[serde(rename = "BwLimit")]
4945        pub bw_limit: ::std::string::String,
4946        #[serde(rename = "BwLimitFile")]
4947        pub bw_limit_file: ::std::string::String,
4948        #[serde(rename = "CaCert")]
4949        pub ca_cert: ::std::vec::Vec<::std::string::String>,
4950        #[serde(rename = "CheckFirst")]
4951        pub check_first: bool,
4952        #[serde(rename = "CheckSum")]
4953        pub check_sum: bool,
4954        #[serde(rename = "Checkers")]
4955        pub checkers: f64,
4956        #[serde(rename = "ClientCert")]
4957        pub client_cert: ::std::string::String,
4958        #[serde(rename = "ClientKey")]
4959        pub client_key: ::std::string::String,
4960        #[serde(rename = "CompareDest")]
4961        pub compare_dest: ::std::vec::Vec<::std::string::String>,
4962        #[serde(rename = "ConnectTimeout")]
4963        pub connect_timeout: f64,
4964        #[serde(rename = "Cookie")]
4965        pub cookie: bool,
4966        #[serde(rename = "CopyDest")]
4967        pub copy_dest: ::std::vec::Vec<::std::string::String>,
4968        #[serde(rename = "CutoffMode")]
4969        pub cutoff_mode: ::std::string::String,
4970        #[serde(rename = "DataRateUnit")]
4971        pub data_rate_unit: ::std::string::String,
4972        #[serde(rename = "DefaultTime")]
4973        pub default_time: ::std::string::String,
4974        #[serde(rename = "DeleteMode")]
4975        pub delete_mode: f64,
4976        #[serde(rename = "DisableFeatures")]
4977        pub disable_features: ::std::option::Option<::std::string::String>,
4978        #[serde(rename = "DisableHTTP2")]
4979        pub disable_http2: bool,
4980        #[serde(rename = "DisableHTTPKeepAlives")]
4981        pub disable_http_keep_alives: bool,
4982        #[serde(rename = "DownloadHeaders")]
4983        pub download_headers: ::std::option::Option<::std::string::String>,
4984        #[serde(rename = "DryRun")]
4985        pub dry_run: bool,
4986        #[serde(rename = "Dump")]
4987        pub dump: ::std::string::String,
4988        #[serde(rename = "ErrorOnNoTransfer")]
4989        pub error_on_no_transfer: bool,
4990        #[serde(rename = "ExpectContinueTimeout")]
4991        pub expect_continue_timeout: f64,
4992        #[serde(rename = "FixCase")]
4993        pub fix_case: bool,
4994        #[serde(rename = "FsCacheExpireDuration")]
4995        pub fs_cache_expire_duration: f64,
4996        #[serde(rename = "FsCacheExpireInterval")]
4997        pub fs_cache_expire_interval: f64,
4998        #[serde(rename = "Headers")]
4999        pub headers: ::std::option::Option<::std::string::String>,
5000        #[serde(rename = "HumanReadable")]
5001        pub human_readable: bool,
5002        #[serde(rename = "IgnoreCaseSync")]
5003        pub ignore_case_sync: bool,
5004        #[serde(rename = "IgnoreChecksum")]
5005        pub ignore_checksum: bool,
5006        #[serde(rename = "IgnoreErrors")]
5007        pub ignore_errors: bool,
5008        #[serde(rename = "IgnoreExisting")]
5009        pub ignore_existing: bool,
5010        #[serde(rename = "IgnoreSize")]
5011        pub ignore_size: bool,
5012        #[serde(rename = "IgnoreTimes")]
5013        pub ignore_times: bool,
5014        #[serde(rename = "Immutable")]
5015        pub immutable: bool,
5016        #[serde(rename = "Inplace")]
5017        pub inplace: bool,
5018        #[serde(rename = "InsecureSkipVerify")]
5019        pub insecure_skip_verify: bool,
5020        #[serde(rename = "Interactive")]
5021        pub interactive: bool,
5022        #[serde(rename = "KvLockTime")]
5023        pub kv_lock_time: f64,
5024        #[serde(rename = "Links")]
5025        pub links: bool,
5026        #[serde(rename = "LogLevel")]
5027        pub log_level: ::std::string::String,
5028        #[serde(rename = "LowLevelRetries")]
5029        pub low_level_retries: f64,
5030        #[serde(rename = "MaxBacklog")]
5031        pub max_backlog: f64,
5032        #[serde(rename = "MaxBufferMemory")]
5033        pub max_buffer_memory: f64,
5034        #[serde(rename = "MaxDelete")]
5035        pub max_delete: f64,
5036        #[serde(rename = "MaxDeleteSize")]
5037        pub max_delete_size: f64,
5038        #[serde(rename = "MaxDepth")]
5039        pub max_depth: f64,
5040        #[serde(rename = "MaxDuration")]
5041        pub max_duration: f64,
5042        #[serde(rename = "MaxStatsGroups")]
5043        pub max_stats_groups: f64,
5044        #[serde(rename = "MaxTransfer")]
5045        pub max_transfer: f64,
5046        #[serde(rename = "Metadata")]
5047        pub metadata: bool,
5048        #[serde(rename = "MetadataMapper")]
5049        pub metadata_mapper: ::std::option::Option<::std::string::String>,
5050        #[serde(rename = "MetadataSet")]
5051        pub metadata_set: ::std::option::Option<::std::string::String>,
5052        #[serde(rename = "ModifyWindow")]
5053        pub modify_window: f64,
5054        #[serde(rename = "MultiThreadChunkSize")]
5055        pub multi_thread_chunk_size: f64,
5056        #[serde(rename = "MultiThreadCutoff")]
5057        pub multi_thread_cutoff: f64,
5058        #[serde(rename = "MultiThreadSet")]
5059        pub multi_thread_set: bool,
5060        #[serde(rename = "MultiThreadStreams")]
5061        pub multi_thread_streams: f64,
5062        #[serde(rename = "MultiThreadWriteBufferSize")]
5063        pub multi_thread_write_buffer_size: f64,
5064        #[serde(rename = "NoCheckDest")]
5065        pub no_check_dest: bool,
5066        #[serde(rename = "NoConsole")]
5067        pub no_console: bool,
5068        #[serde(rename = "NoGzip")]
5069        pub no_gzip: bool,
5070        #[serde(rename = "NoTraverse")]
5071        pub no_traverse: bool,
5072        #[serde(rename = "NoUnicodeNormalization")]
5073        pub no_unicode_normalization: bool,
5074        #[serde(rename = "NoUpdateDirModTime")]
5075        pub no_update_dir_mod_time: bool,
5076        #[serde(rename = "NoUpdateModTime")]
5077        pub no_update_mod_time: bool,
5078        #[serde(rename = "OrderBy")]
5079        pub order_by: ::std::string::String,
5080        #[serde(rename = "PartialSuffix")]
5081        pub partial_suffix: ::std::string::String,
5082        #[serde(rename = "PasswordCommand")]
5083        pub password_command: ::std::option::Option<::std::string::String>,
5084        #[serde(rename = "Progress")]
5085        pub progress: bool,
5086        #[serde(rename = "ProgressTerminalTitle")]
5087        pub progress_terminal_title: bool,
5088        #[serde(rename = "RefreshTimes")]
5089        pub refresh_times: bool,
5090        #[serde(rename = "Retries")]
5091        pub retries: f64,
5092        #[serde(rename = "RetriesInterval")]
5093        pub retries_interval: f64,
5094        #[serde(rename = "ServerSideAcrossConfigs")]
5095        pub server_side_across_configs: bool,
5096        #[serde(rename = "SizeOnly")]
5097        pub size_only: bool,
5098        #[serde(rename = "StatsFileNameLength")]
5099        pub stats_file_name_length: f64,
5100        #[serde(rename = "StatsLogLevel")]
5101        pub stats_log_level: ::std::string::String,
5102        #[serde(rename = "StatsOneLine")]
5103        pub stats_one_line: bool,
5104        #[serde(rename = "StatsOneLineDate")]
5105        pub stats_one_line_date: bool,
5106        #[serde(rename = "StatsOneLineDateFormat")]
5107        pub stats_one_line_date_format: ::std::string::String,
5108        #[serde(rename = "StreamingUploadCutoff")]
5109        pub streaming_upload_cutoff: f64,
5110        #[serde(rename = "Suffix")]
5111        pub suffix: ::std::string::String,
5112        #[serde(rename = "SuffixKeepExtension")]
5113        pub suffix_keep_extension: bool,
5114        #[serde(rename = "TerminalColorMode")]
5115        pub terminal_color_mode: ::std::string::String,
5116        #[serde(rename = "Timeout")]
5117        pub timeout: f64,
5118        #[serde(rename = "TPSLimit")]
5119        pub tps_limit: f64,
5120        #[serde(rename = "TPSLimitBurst")]
5121        pub tps_limit_burst: f64,
5122        #[serde(rename = "TrackRenames")]
5123        pub track_renames: bool,
5124        #[serde(rename = "TrackRenamesStrategy")]
5125        pub track_renames_strategy: ::std::string::String,
5126        #[serde(rename = "TrafficClass")]
5127        pub traffic_class: f64,
5128        #[serde(rename = "Transfers")]
5129        pub transfers: f64,
5130        #[serde(rename = "UpdateOlder")]
5131        pub update_older: bool,
5132        #[serde(rename = "UploadHeaders")]
5133        pub upload_headers: ::std::option::Option<::std::string::String>,
5134        #[serde(rename = "UseJSONLog")]
5135        pub use_json_log: bool,
5136        #[serde(rename = "UseListR")]
5137        pub use_list_r: bool,
5138        #[serde(rename = "UseMmap")]
5139        pub use_mmap: bool,
5140        #[serde(rename = "UseServerModTime")]
5141        pub use_server_mod_time: bool,
5142        #[serde(rename = "UserAgent")]
5143        pub user_agent: ::std::string::String,
5144    }
5145
5146    impl ::std::convert::From<&OptionsLocalResponseConfig> for OptionsLocalResponseConfig {
5147        fn from(value: &OptionsLocalResponseConfig) -> Self {
5148            value.clone()
5149        }
5150    }
5151
5152    ///`OptionsLocalResponseFilter`
5153    ///
5154    /// <details><summary>JSON schema</summary>
5155    ///
5156    /// ```json
5157    ///{
5158    ///  "type": "object",
5159    ///  "required": [
5160    ///    "DeleteExcluded",
5161    ///    "ExcludeFile",
5162    ///    "ExcludeFrom",
5163    ///    "ExcludeRule",
5164    ///    "FilesFrom",
5165    ///    "FilesFromRaw",
5166    ///    "FilterFrom",
5167    ///    "FilterRule",
5168    ///    "HashFilter",
5169    ///    "IgnoreCase",
5170    ///    "IncludeFrom",
5171    ///    "IncludeRule",
5172    ///    "MaxAge",
5173    ///    "MaxSize",
5174    ///    "MetaRules",
5175    ///    "MinAge",
5176    ///    "MinSize"
5177    ///  ],
5178    ///  "properties": {
5179    ///    "DeleteExcluded": {
5180    ///      "type": "boolean"
5181    ///    },
5182    ///    "ExcludeFile": {
5183    ///      "type": "array",
5184    ///      "items": {
5185    ///        "type": "string"
5186    ///      }
5187    ///    },
5188    ///    "ExcludeFrom": {
5189    ///      "type": "array",
5190    ///      "items": {
5191    ///        "type": "string"
5192    ///      }
5193    ///    },
5194    ///    "ExcludeRule": {
5195    ///      "type": "array",
5196    ///      "items": {
5197    ///        "type": "string"
5198    ///      }
5199    ///    },
5200    ///    "FilesFrom": {
5201    ///      "type": "array",
5202    ///      "items": {
5203    ///        "type": "string"
5204    ///      }
5205    ///    },
5206    ///    "FilesFromRaw": {
5207    ///      "type": "array",
5208    ///      "items": {
5209    ///        "type": "string"
5210    ///      }
5211    ///    },
5212    ///    "FilterFrom": {
5213    ///      "type": "array",
5214    ///      "items": {
5215    ///        "type": "string"
5216    ///      }
5217    ///    },
5218    ///    "FilterRule": {
5219    ///      "type": "array",
5220    ///      "items": {
5221    ///        "type": "string"
5222    ///      }
5223    ///    },
5224    ///    "HashFilter": {
5225    ///      "type": "string"
5226    ///    },
5227    ///    "IgnoreCase": {
5228    ///      "type": "boolean"
5229    ///    },
5230    ///    "IncludeFrom": {
5231    ///      "type": "array",
5232    ///      "items": {
5233    ///        "type": "string"
5234    ///      }
5235    ///    },
5236    ///    "IncludeRule": {
5237    ///      "type": "array",
5238    ///      "items": {
5239    ///        "type": "string"
5240    ///      }
5241    ///    },
5242    ///    "MaxAge": {
5243    ///      "type": "number"
5244    ///    },
5245    ///    "MaxSize": {
5246    ///      "type": "number"
5247    ///    },
5248    ///    "MetaRules": {
5249    ///      "type": "object",
5250    ///      "required": [
5251    ///        "ExcludeFrom",
5252    ///        "ExcludeRule",
5253    ///        "FilterFrom",
5254    ///        "FilterRule",
5255    ///        "IncludeFrom",
5256    ///        "IncludeRule"
5257    ///      ],
5258    ///      "properties": {
5259    ///        "ExcludeFrom": {
5260    ///          "type": "array",
5261    ///          "items": {
5262    ///            "type": "string"
5263    ///          }
5264    ///        },
5265    ///        "ExcludeRule": {
5266    ///          "type": "array",
5267    ///          "items": {
5268    ///            "type": "string"
5269    ///          }
5270    ///        },
5271    ///        "FilterFrom": {
5272    ///          "type": "array",
5273    ///          "items": {
5274    ///            "type": "string"
5275    ///          }
5276    ///        },
5277    ///        "FilterRule": {
5278    ///          "type": "array",
5279    ///          "items": {
5280    ///            "type": "string"
5281    ///          }
5282    ///        },
5283    ///        "IncludeFrom": {
5284    ///          "type": "array",
5285    ///          "items": {
5286    ///            "type": "string"
5287    ///          }
5288    ///        },
5289    ///        "IncludeRule": {
5290    ///          "type": "array",
5291    ///          "items": {
5292    ///            "type": "string"
5293    ///          }
5294    ///        }
5295    ///      }
5296    ///    },
5297    ///    "MinAge": {
5298    ///      "type": "number"
5299    ///    },
5300    ///    "MinSize": {
5301    ///      "type": "number"
5302    ///    }
5303    ///  }
5304    ///}
5305    /// ```
5306    /// </details>
5307    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5308    pub struct OptionsLocalResponseFilter {
5309        #[serde(rename = "DeleteExcluded")]
5310        pub delete_excluded: bool,
5311        #[serde(rename = "ExcludeFile")]
5312        pub exclude_file: ::std::vec::Vec<::std::string::String>,
5313        #[serde(rename = "ExcludeFrom")]
5314        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5315        #[serde(rename = "ExcludeRule")]
5316        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5317        #[serde(rename = "FilesFrom")]
5318        pub files_from: ::std::vec::Vec<::std::string::String>,
5319        #[serde(rename = "FilesFromRaw")]
5320        pub files_from_raw: ::std::vec::Vec<::std::string::String>,
5321        #[serde(rename = "FilterFrom")]
5322        pub filter_from: ::std::vec::Vec<::std::string::String>,
5323        #[serde(rename = "FilterRule")]
5324        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5325        #[serde(rename = "HashFilter")]
5326        pub hash_filter: ::std::string::String,
5327        #[serde(rename = "IgnoreCase")]
5328        pub ignore_case: bool,
5329        #[serde(rename = "IncludeFrom")]
5330        pub include_from: ::std::vec::Vec<::std::string::String>,
5331        #[serde(rename = "IncludeRule")]
5332        pub include_rule: ::std::vec::Vec<::std::string::String>,
5333        #[serde(rename = "MaxAge")]
5334        pub max_age: f64,
5335        #[serde(rename = "MaxSize")]
5336        pub max_size: f64,
5337        #[serde(rename = "MetaRules")]
5338        pub meta_rules: OptionsLocalResponseFilterMetaRules,
5339        #[serde(rename = "MinAge")]
5340        pub min_age: f64,
5341        #[serde(rename = "MinSize")]
5342        pub min_size: f64,
5343    }
5344
5345    impl ::std::convert::From<&OptionsLocalResponseFilter> for OptionsLocalResponseFilter {
5346        fn from(value: &OptionsLocalResponseFilter) -> Self {
5347            value.clone()
5348        }
5349    }
5350
5351    ///`OptionsLocalResponseFilterMetaRules`
5352    ///
5353    /// <details><summary>JSON schema</summary>
5354    ///
5355    /// ```json
5356    ///{
5357    ///  "type": "object",
5358    ///  "required": [
5359    ///    "ExcludeFrom",
5360    ///    "ExcludeRule",
5361    ///    "FilterFrom",
5362    ///    "FilterRule",
5363    ///    "IncludeFrom",
5364    ///    "IncludeRule"
5365    ///  ],
5366    ///  "properties": {
5367    ///    "ExcludeFrom": {
5368    ///      "type": "array",
5369    ///      "items": {
5370    ///        "type": "string"
5371    ///      }
5372    ///    },
5373    ///    "ExcludeRule": {
5374    ///      "type": "array",
5375    ///      "items": {
5376    ///        "type": "string"
5377    ///      }
5378    ///    },
5379    ///    "FilterFrom": {
5380    ///      "type": "array",
5381    ///      "items": {
5382    ///        "type": "string"
5383    ///      }
5384    ///    },
5385    ///    "FilterRule": {
5386    ///      "type": "array",
5387    ///      "items": {
5388    ///        "type": "string"
5389    ///      }
5390    ///    },
5391    ///    "IncludeFrom": {
5392    ///      "type": "array",
5393    ///      "items": {
5394    ///        "type": "string"
5395    ///      }
5396    ///    },
5397    ///    "IncludeRule": {
5398    ///      "type": "array",
5399    ///      "items": {
5400    ///        "type": "string"
5401    ///      }
5402    ///    }
5403    ///  }
5404    ///}
5405    /// ```
5406    /// </details>
5407    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5408    pub struct OptionsLocalResponseFilterMetaRules {
5409        #[serde(rename = "ExcludeFrom")]
5410        pub exclude_from: ::std::vec::Vec<::std::string::String>,
5411        #[serde(rename = "ExcludeRule")]
5412        pub exclude_rule: ::std::vec::Vec<::std::string::String>,
5413        #[serde(rename = "FilterFrom")]
5414        pub filter_from: ::std::vec::Vec<::std::string::String>,
5415        #[serde(rename = "FilterRule")]
5416        pub filter_rule: ::std::vec::Vec<::std::string::String>,
5417        #[serde(rename = "IncludeFrom")]
5418        pub include_from: ::std::vec::Vec<::std::string::String>,
5419        #[serde(rename = "IncludeRule")]
5420        pub include_rule: ::std::vec::Vec<::std::string::String>,
5421    }
5422
5423    impl ::std::convert::From<&OptionsLocalResponseFilterMetaRules>
5424        for OptionsLocalResponseFilterMetaRules
5425    {
5426        fn from(value: &OptionsLocalResponseFilterMetaRules) -> Self {
5427            value.clone()
5428        }
5429    }
5430
5431    ///`OptionsSetDlnaValue`
5432    ///
5433    /// <details><summary>JSON schema</summary>
5434    ///
5435    /// ```json
5436    ///{
5437    ///  "oneOf": [
5438    ///    {
5439    ///      "type": "string"
5440    ///    },
5441    ///    {
5442    ///      "type": "number"
5443    ///    },
5444    ///    {
5445    ///      "type": "integer"
5446    ///    },
5447    ///    {
5448    ///      "type": "boolean"
5449    ///    },
5450    ///    {
5451    ///      "type": "array",
5452    ///      "items": {}
5453    ///    },
5454    ///    {
5455    ///      "type": "object",
5456    ///      "additionalProperties": {}
5457    ///    }
5458    ///  ]
5459    ///}
5460    /// ```
5461    /// </details>
5462    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5463    #[serde(untagged)]
5464    pub enum OptionsSetDlnaValue {
5465        Variant0(::std::string::String),
5466        Variant1(f64),
5467        Variant2(i64),
5468        Variant3(bool),
5469        Variant4(::std::vec::Vec<::serde_json::Value>),
5470        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5471    }
5472
5473    impl ::std::convert::From<&Self> for OptionsSetDlnaValue {
5474        fn from(value: &OptionsSetDlnaValue) -> Self {
5475            value.clone()
5476        }
5477    }
5478
5479    impl ::std::convert::From<f64> for OptionsSetDlnaValue {
5480        fn from(value: f64) -> Self {
5481            Self::Variant1(value)
5482        }
5483    }
5484
5485    impl ::std::convert::From<i64> for OptionsSetDlnaValue {
5486        fn from(value: i64) -> Self {
5487            Self::Variant2(value)
5488        }
5489    }
5490
5491    impl ::std::convert::From<bool> for OptionsSetDlnaValue {
5492        fn from(value: bool) -> Self {
5493            Self::Variant3(value)
5494        }
5495    }
5496
5497    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetDlnaValue {
5498        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5499            Self::Variant4(value)
5500        }
5501    }
5502
5503    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5504        for OptionsSetDlnaValue
5505    {
5506        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5507            Self::Variant5(value)
5508        }
5509    }
5510
5511    ///`OptionsSetFilterValue`
5512    ///
5513    /// <details><summary>JSON schema</summary>
5514    ///
5515    /// ```json
5516    ///{
5517    ///  "oneOf": [
5518    ///    {
5519    ///      "type": "string"
5520    ///    },
5521    ///    {
5522    ///      "type": "number"
5523    ///    },
5524    ///    {
5525    ///      "type": "integer"
5526    ///    },
5527    ///    {
5528    ///      "type": "boolean"
5529    ///    },
5530    ///    {
5531    ///      "type": "array",
5532    ///      "items": {}
5533    ///    },
5534    ///    {
5535    ///      "type": "object",
5536    ///      "additionalProperties": {}
5537    ///    }
5538    ///  ]
5539    ///}
5540    /// ```
5541    /// </details>
5542    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5543    #[serde(untagged)]
5544    pub enum OptionsSetFilterValue {
5545        Variant0(::std::string::String),
5546        Variant1(f64),
5547        Variant2(i64),
5548        Variant3(bool),
5549        Variant4(::std::vec::Vec<::serde_json::Value>),
5550        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5551    }
5552
5553    impl ::std::convert::From<&Self> for OptionsSetFilterValue {
5554        fn from(value: &OptionsSetFilterValue) -> Self {
5555            value.clone()
5556        }
5557    }
5558
5559    impl ::std::convert::From<f64> for OptionsSetFilterValue {
5560        fn from(value: f64) -> Self {
5561            Self::Variant1(value)
5562        }
5563    }
5564
5565    impl ::std::convert::From<i64> for OptionsSetFilterValue {
5566        fn from(value: i64) -> Self {
5567            Self::Variant2(value)
5568        }
5569    }
5570
5571    impl ::std::convert::From<bool> for OptionsSetFilterValue {
5572        fn from(value: bool) -> Self {
5573            Self::Variant3(value)
5574        }
5575    }
5576
5577    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFilterValue {
5578        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5579            Self::Variant4(value)
5580        }
5581    }
5582
5583    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5584        for OptionsSetFilterValue
5585    {
5586        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5587            Self::Variant5(value)
5588        }
5589    }
5590
5591    ///`OptionsSetFtpValue`
5592    ///
5593    /// <details><summary>JSON schema</summary>
5594    ///
5595    /// ```json
5596    ///{
5597    ///  "oneOf": [
5598    ///    {
5599    ///      "type": "string"
5600    ///    },
5601    ///    {
5602    ///      "type": "number"
5603    ///    },
5604    ///    {
5605    ///      "type": "integer"
5606    ///    },
5607    ///    {
5608    ///      "type": "boolean"
5609    ///    },
5610    ///    {
5611    ///      "type": "array",
5612    ///      "items": {}
5613    ///    },
5614    ///    {
5615    ///      "type": "object",
5616    ///      "additionalProperties": {}
5617    ///    }
5618    ///  ]
5619    ///}
5620    /// ```
5621    /// </details>
5622    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5623    #[serde(untagged)]
5624    pub enum OptionsSetFtpValue {
5625        Variant0(::std::string::String),
5626        Variant1(f64),
5627        Variant2(i64),
5628        Variant3(bool),
5629        Variant4(::std::vec::Vec<::serde_json::Value>),
5630        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5631    }
5632
5633    impl ::std::convert::From<&Self> for OptionsSetFtpValue {
5634        fn from(value: &OptionsSetFtpValue) -> Self {
5635            value.clone()
5636        }
5637    }
5638
5639    impl ::std::convert::From<f64> for OptionsSetFtpValue {
5640        fn from(value: f64) -> Self {
5641            Self::Variant1(value)
5642        }
5643    }
5644
5645    impl ::std::convert::From<i64> for OptionsSetFtpValue {
5646        fn from(value: i64) -> Self {
5647            Self::Variant2(value)
5648        }
5649    }
5650
5651    impl ::std::convert::From<bool> for OptionsSetFtpValue {
5652        fn from(value: bool) -> Self {
5653            Self::Variant3(value)
5654        }
5655    }
5656
5657    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetFtpValue {
5658        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5659            Self::Variant4(value)
5660        }
5661    }
5662
5663    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5664        for OptionsSetFtpValue
5665    {
5666        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5667            Self::Variant5(value)
5668        }
5669    }
5670
5671    ///`OptionsSetHttpValue`
5672    ///
5673    /// <details><summary>JSON schema</summary>
5674    ///
5675    /// ```json
5676    ///{
5677    ///  "oneOf": [
5678    ///    {
5679    ///      "type": "string"
5680    ///    },
5681    ///    {
5682    ///      "type": "number"
5683    ///    },
5684    ///    {
5685    ///      "type": "integer"
5686    ///    },
5687    ///    {
5688    ///      "type": "boolean"
5689    ///    },
5690    ///    {
5691    ///      "type": "array",
5692    ///      "items": {}
5693    ///    },
5694    ///    {
5695    ///      "type": "object",
5696    ///      "additionalProperties": {}
5697    ///    }
5698    ///  ]
5699    ///}
5700    /// ```
5701    /// </details>
5702    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5703    #[serde(untagged)]
5704    pub enum OptionsSetHttpValue {
5705        Variant0(::std::string::String),
5706        Variant1(f64),
5707        Variant2(i64),
5708        Variant3(bool),
5709        Variant4(::std::vec::Vec<::serde_json::Value>),
5710        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5711    }
5712
5713    impl ::std::convert::From<&Self> for OptionsSetHttpValue {
5714        fn from(value: &OptionsSetHttpValue) -> Self {
5715            value.clone()
5716        }
5717    }
5718
5719    impl ::std::convert::From<f64> for OptionsSetHttpValue {
5720        fn from(value: f64) -> Self {
5721            Self::Variant1(value)
5722        }
5723    }
5724
5725    impl ::std::convert::From<i64> for OptionsSetHttpValue {
5726        fn from(value: i64) -> Self {
5727            Self::Variant2(value)
5728        }
5729    }
5730
5731    impl ::std::convert::From<bool> for OptionsSetHttpValue {
5732        fn from(value: bool) -> Self {
5733            Self::Variant3(value)
5734        }
5735    }
5736
5737    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetHttpValue {
5738        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5739            Self::Variant4(value)
5740        }
5741    }
5742
5743    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5744        for OptionsSetHttpValue
5745    {
5746        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5747            Self::Variant5(value)
5748        }
5749    }
5750
5751    ///`OptionsSetLogValue`
5752    ///
5753    /// <details><summary>JSON schema</summary>
5754    ///
5755    /// ```json
5756    ///{
5757    ///  "oneOf": [
5758    ///    {
5759    ///      "type": "string"
5760    ///    },
5761    ///    {
5762    ///      "type": "number"
5763    ///    },
5764    ///    {
5765    ///      "type": "integer"
5766    ///    },
5767    ///    {
5768    ///      "type": "boolean"
5769    ///    },
5770    ///    {
5771    ///      "type": "array",
5772    ///      "items": {}
5773    ///    },
5774    ///    {
5775    ///      "type": "object",
5776    ///      "additionalProperties": {}
5777    ///    }
5778    ///  ]
5779    ///}
5780    /// ```
5781    /// </details>
5782    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5783    #[serde(untagged)]
5784    pub enum OptionsSetLogValue {
5785        Variant0(::std::string::String),
5786        Variant1(f64),
5787        Variant2(i64),
5788        Variant3(bool),
5789        Variant4(::std::vec::Vec<::serde_json::Value>),
5790        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5791    }
5792
5793    impl ::std::convert::From<&Self> for OptionsSetLogValue {
5794        fn from(value: &OptionsSetLogValue) -> Self {
5795            value.clone()
5796        }
5797    }
5798
5799    impl ::std::convert::From<f64> for OptionsSetLogValue {
5800        fn from(value: f64) -> Self {
5801            Self::Variant1(value)
5802        }
5803    }
5804
5805    impl ::std::convert::From<i64> for OptionsSetLogValue {
5806        fn from(value: i64) -> Self {
5807            Self::Variant2(value)
5808        }
5809    }
5810
5811    impl ::std::convert::From<bool> for OptionsSetLogValue {
5812        fn from(value: bool) -> Self {
5813            Self::Variant3(value)
5814        }
5815    }
5816
5817    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetLogValue {
5818        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5819            Self::Variant4(value)
5820        }
5821    }
5822
5823    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5824        for OptionsSetLogValue
5825    {
5826        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5827            Self::Variant5(value)
5828        }
5829    }
5830
5831    ///`OptionsSetMainValue`
5832    ///
5833    /// <details><summary>JSON schema</summary>
5834    ///
5835    /// ```json
5836    ///{
5837    ///  "oneOf": [
5838    ///    {
5839    ///      "type": "string"
5840    ///    },
5841    ///    {
5842    ///      "type": "number"
5843    ///    },
5844    ///    {
5845    ///      "type": "integer"
5846    ///    },
5847    ///    {
5848    ///      "type": "boolean"
5849    ///    },
5850    ///    {
5851    ///      "type": "array",
5852    ///      "items": {}
5853    ///    },
5854    ///    {
5855    ///      "type": "object",
5856    ///      "additionalProperties": {}
5857    ///    }
5858    ///  ]
5859    ///}
5860    /// ```
5861    /// </details>
5862    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5863    #[serde(untagged)]
5864    pub enum OptionsSetMainValue {
5865        Variant0(::std::string::String),
5866        Variant1(f64),
5867        Variant2(i64),
5868        Variant3(bool),
5869        Variant4(::std::vec::Vec<::serde_json::Value>),
5870        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5871    }
5872
5873    impl ::std::convert::From<&Self> for OptionsSetMainValue {
5874        fn from(value: &OptionsSetMainValue) -> Self {
5875            value.clone()
5876        }
5877    }
5878
5879    impl ::std::convert::From<f64> for OptionsSetMainValue {
5880        fn from(value: f64) -> Self {
5881            Self::Variant1(value)
5882        }
5883    }
5884
5885    impl ::std::convert::From<i64> for OptionsSetMainValue {
5886        fn from(value: i64) -> Self {
5887            Self::Variant2(value)
5888        }
5889    }
5890
5891    impl ::std::convert::From<bool> for OptionsSetMainValue {
5892        fn from(value: bool) -> Self {
5893            Self::Variant3(value)
5894        }
5895    }
5896
5897    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMainValue {
5898        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5899            Self::Variant4(value)
5900        }
5901    }
5902
5903    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5904        for OptionsSetMainValue
5905    {
5906        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5907            Self::Variant5(value)
5908        }
5909    }
5910
5911    ///`OptionsSetMountValue`
5912    ///
5913    /// <details><summary>JSON schema</summary>
5914    ///
5915    /// ```json
5916    ///{
5917    ///  "oneOf": [
5918    ///    {
5919    ///      "type": "string"
5920    ///    },
5921    ///    {
5922    ///      "type": "number"
5923    ///    },
5924    ///    {
5925    ///      "type": "integer"
5926    ///    },
5927    ///    {
5928    ///      "type": "boolean"
5929    ///    },
5930    ///    {
5931    ///      "type": "array",
5932    ///      "items": {}
5933    ///    },
5934    ///    {
5935    ///      "type": "object",
5936    ///      "additionalProperties": {}
5937    ///    }
5938    ///  ]
5939    ///}
5940    /// ```
5941    /// </details>
5942    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5943    #[serde(untagged)]
5944    pub enum OptionsSetMountValue {
5945        Variant0(::std::string::String),
5946        Variant1(f64),
5947        Variant2(i64),
5948        Variant3(bool),
5949        Variant4(::std::vec::Vec<::serde_json::Value>),
5950        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
5951    }
5952
5953    impl ::std::convert::From<&Self> for OptionsSetMountValue {
5954        fn from(value: &OptionsSetMountValue) -> Self {
5955            value.clone()
5956        }
5957    }
5958
5959    impl ::std::convert::From<f64> for OptionsSetMountValue {
5960        fn from(value: f64) -> Self {
5961            Self::Variant1(value)
5962        }
5963    }
5964
5965    impl ::std::convert::From<i64> for OptionsSetMountValue {
5966        fn from(value: i64) -> Self {
5967            Self::Variant2(value)
5968        }
5969    }
5970
5971    impl ::std::convert::From<bool> for OptionsSetMountValue {
5972        fn from(value: bool) -> Self {
5973            Self::Variant3(value)
5974        }
5975    }
5976
5977    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetMountValue {
5978        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
5979            Self::Variant4(value)
5980        }
5981    }
5982
5983    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
5984        for OptionsSetMountValue
5985    {
5986        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
5987            Self::Variant5(value)
5988        }
5989    }
5990
5991    ///`OptionsSetNfsValue`
5992    ///
5993    /// <details><summary>JSON schema</summary>
5994    ///
5995    /// ```json
5996    ///{
5997    ///  "oneOf": [
5998    ///    {
5999    ///      "type": "string"
6000    ///    },
6001    ///    {
6002    ///      "type": "number"
6003    ///    },
6004    ///    {
6005    ///      "type": "integer"
6006    ///    },
6007    ///    {
6008    ///      "type": "boolean"
6009    ///    },
6010    ///    {
6011    ///      "type": "array",
6012    ///      "items": {}
6013    ///    },
6014    ///    {
6015    ///      "type": "object",
6016    ///      "additionalProperties": {}
6017    ///    }
6018    ///  ]
6019    ///}
6020    /// ```
6021    /// </details>
6022    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6023    #[serde(untagged)]
6024    pub enum OptionsSetNfsValue {
6025        Variant0(::std::string::String),
6026        Variant1(f64),
6027        Variant2(i64),
6028        Variant3(bool),
6029        Variant4(::std::vec::Vec<::serde_json::Value>),
6030        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6031    }
6032
6033    impl ::std::convert::From<&Self> for OptionsSetNfsValue {
6034        fn from(value: &OptionsSetNfsValue) -> Self {
6035            value.clone()
6036        }
6037    }
6038
6039    impl ::std::convert::From<f64> for OptionsSetNfsValue {
6040        fn from(value: f64) -> Self {
6041            Self::Variant1(value)
6042        }
6043    }
6044
6045    impl ::std::convert::From<i64> for OptionsSetNfsValue {
6046        fn from(value: i64) -> Self {
6047            Self::Variant2(value)
6048        }
6049    }
6050
6051    impl ::std::convert::From<bool> for OptionsSetNfsValue {
6052        fn from(value: bool) -> Self {
6053            Self::Variant3(value)
6054        }
6055    }
6056
6057    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetNfsValue {
6058        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6059            Self::Variant4(value)
6060        }
6061    }
6062
6063    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6064        for OptionsSetNfsValue
6065    {
6066        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6067            Self::Variant5(value)
6068        }
6069    }
6070
6071    ///`OptionsSetProxyValue`
6072    ///
6073    /// <details><summary>JSON schema</summary>
6074    ///
6075    /// ```json
6076    ///{
6077    ///  "oneOf": [
6078    ///    {
6079    ///      "type": "string"
6080    ///    },
6081    ///    {
6082    ///      "type": "number"
6083    ///    },
6084    ///    {
6085    ///      "type": "integer"
6086    ///    },
6087    ///    {
6088    ///      "type": "boolean"
6089    ///    },
6090    ///    {
6091    ///      "type": "array",
6092    ///      "items": {}
6093    ///    },
6094    ///    {
6095    ///      "type": "object",
6096    ///      "additionalProperties": {}
6097    ///    }
6098    ///  ]
6099    ///}
6100    /// ```
6101    /// </details>
6102    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6103    #[serde(untagged)]
6104    pub enum OptionsSetProxyValue {
6105        Variant0(::std::string::String),
6106        Variant1(f64),
6107        Variant2(i64),
6108        Variant3(bool),
6109        Variant4(::std::vec::Vec<::serde_json::Value>),
6110        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6111    }
6112
6113    impl ::std::convert::From<&Self> for OptionsSetProxyValue {
6114        fn from(value: &OptionsSetProxyValue) -> Self {
6115            value.clone()
6116        }
6117    }
6118
6119    impl ::std::convert::From<f64> for OptionsSetProxyValue {
6120        fn from(value: f64) -> Self {
6121            Self::Variant1(value)
6122        }
6123    }
6124
6125    impl ::std::convert::From<i64> for OptionsSetProxyValue {
6126        fn from(value: i64) -> Self {
6127            Self::Variant2(value)
6128        }
6129    }
6130
6131    impl ::std::convert::From<bool> for OptionsSetProxyValue {
6132        fn from(value: bool) -> Self {
6133            Self::Variant3(value)
6134        }
6135    }
6136
6137    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetProxyValue {
6138        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6139            Self::Variant4(value)
6140        }
6141    }
6142
6143    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6144        for OptionsSetProxyValue
6145    {
6146        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6147            Self::Variant5(value)
6148        }
6149    }
6150
6151    ///`OptionsSetRcValue`
6152    ///
6153    /// <details><summary>JSON schema</summary>
6154    ///
6155    /// ```json
6156    ///{
6157    ///  "oneOf": [
6158    ///    {
6159    ///      "type": "string"
6160    ///    },
6161    ///    {
6162    ///      "type": "number"
6163    ///    },
6164    ///    {
6165    ///      "type": "integer"
6166    ///    },
6167    ///    {
6168    ///      "type": "boolean"
6169    ///    },
6170    ///    {
6171    ///      "type": "array",
6172    ///      "items": {}
6173    ///    },
6174    ///    {
6175    ///      "type": "object",
6176    ///      "additionalProperties": {}
6177    ///    }
6178    ///  ]
6179    ///}
6180    /// ```
6181    /// </details>
6182    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6183    #[serde(untagged)]
6184    pub enum OptionsSetRcValue {
6185        Variant0(::std::string::String),
6186        Variant1(f64),
6187        Variant2(i64),
6188        Variant3(bool),
6189        Variant4(::std::vec::Vec<::serde_json::Value>),
6190        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6191    }
6192
6193    impl ::std::convert::From<&Self> for OptionsSetRcValue {
6194        fn from(value: &OptionsSetRcValue) -> Self {
6195            value.clone()
6196        }
6197    }
6198
6199    impl ::std::convert::From<f64> for OptionsSetRcValue {
6200        fn from(value: f64) -> Self {
6201            Self::Variant1(value)
6202        }
6203    }
6204
6205    impl ::std::convert::From<i64> for OptionsSetRcValue {
6206        fn from(value: i64) -> Self {
6207            Self::Variant2(value)
6208        }
6209    }
6210
6211    impl ::std::convert::From<bool> for OptionsSetRcValue {
6212        fn from(value: bool) -> Self {
6213            Self::Variant3(value)
6214        }
6215    }
6216
6217    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetRcValue {
6218        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6219            Self::Variant4(value)
6220        }
6221    }
6222
6223    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6224        for OptionsSetRcValue
6225    {
6226        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6227            Self::Variant5(value)
6228        }
6229    }
6230
6231    ///`OptionsSetResticValue`
6232    ///
6233    /// <details><summary>JSON schema</summary>
6234    ///
6235    /// ```json
6236    ///{
6237    ///  "oneOf": [
6238    ///    {
6239    ///      "type": "string"
6240    ///    },
6241    ///    {
6242    ///      "type": "number"
6243    ///    },
6244    ///    {
6245    ///      "type": "integer"
6246    ///    },
6247    ///    {
6248    ///      "type": "boolean"
6249    ///    },
6250    ///    {
6251    ///      "type": "array",
6252    ///      "items": {}
6253    ///    },
6254    ///    {
6255    ///      "type": "object",
6256    ///      "additionalProperties": {}
6257    ///    }
6258    ///  ]
6259    ///}
6260    /// ```
6261    /// </details>
6262    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6263    #[serde(untagged)]
6264    pub enum OptionsSetResticValue {
6265        Variant0(::std::string::String),
6266        Variant1(f64),
6267        Variant2(i64),
6268        Variant3(bool),
6269        Variant4(::std::vec::Vec<::serde_json::Value>),
6270        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6271    }
6272
6273    impl ::std::convert::From<&Self> for OptionsSetResticValue {
6274        fn from(value: &OptionsSetResticValue) -> Self {
6275            value.clone()
6276        }
6277    }
6278
6279    impl ::std::convert::From<f64> for OptionsSetResticValue {
6280        fn from(value: f64) -> Self {
6281            Self::Variant1(value)
6282        }
6283    }
6284
6285    impl ::std::convert::From<i64> for OptionsSetResticValue {
6286        fn from(value: i64) -> Self {
6287            Self::Variant2(value)
6288        }
6289    }
6290
6291    impl ::std::convert::From<bool> for OptionsSetResticValue {
6292        fn from(value: bool) -> Self {
6293            Self::Variant3(value)
6294        }
6295    }
6296
6297    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetResticValue {
6298        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6299            Self::Variant4(value)
6300        }
6301    }
6302
6303    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6304        for OptionsSetResticValue
6305    {
6306        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6307            Self::Variant5(value)
6308        }
6309    }
6310
6311    ///`OptionsSetS3Value`
6312    ///
6313    /// <details><summary>JSON schema</summary>
6314    ///
6315    /// ```json
6316    ///{
6317    ///  "oneOf": [
6318    ///    {
6319    ///      "type": "string"
6320    ///    },
6321    ///    {
6322    ///      "type": "number"
6323    ///    },
6324    ///    {
6325    ///      "type": "integer"
6326    ///    },
6327    ///    {
6328    ///      "type": "boolean"
6329    ///    },
6330    ///    {
6331    ///      "type": "array",
6332    ///      "items": {}
6333    ///    },
6334    ///    {
6335    ///      "type": "object",
6336    ///      "additionalProperties": {}
6337    ///    }
6338    ///  ]
6339    ///}
6340    /// ```
6341    /// </details>
6342    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6343    #[serde(untagged)]
6344    pub enum OptionsSetS3Value {
6345        Variant0(::std::string::String),
6346        Variant1(f64),
6347        Variant2(i64),
6348        Variant3(bool),
6349        Variant4(::std::vec::Vec<::serde_json::Value>),
6350        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6351    }
6352
6353    impl ::std::convert::From<&Self> for OptionsSetS3Value {
6354        fn from(value: &OptionsSetS3Value) -> Self {
6355            value.clone()
6356        }
6357    }
6358
6359    impl ::std::convert::From<f64> for OptionsSetS3Value {
6360        fn from(value: f64) -> Self {
6361            Self::Variant1(value)
6362        }
6363    }
6364
6365    impl ::std::convert::From<i64> for OptionsSetS3Value {
6366        fn from(value: i64) -> Self {
6367            Self::Variant2(value)
6368        }
6369    }
6370
6371    impl ::std::convert::From<bool> for OptionsSetS3Value {
6372        fn from(value: bool) -> Self {
6373            Self::Variant3(value)
6374        }
6375    }
6376
6377    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetS3Value {
6378        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6379            Self::Variant4(value)
6380        }
6381    }
6382
6383    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6384        for OptionsSetS3Value
6385    {
6386        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6387            Self::Variant5(value)
6388        }
6389    }
6390
6391    ///`OptionsSetSftpValue`
6392    ///
6393    /// <details><summary>JSON schema</summary>
6394    ///
6395    /// ```json
6396    ///{
6397    ///  "oneOf": [
6398    ///    {
6399    ///      "type": "string"
6400    ///    },
6401    ///    {
6402    ///      "type": "number"
6403    ///    },
6404    ///    {
6405    ///      "type": "integer"
6406    ///    },
6407    ///    {
6408    ///      "type": "boolean"
6409    ///    },
6410    ///    {
6411    ///      "type": "array",
6412    ///      "items": {}
6413    ///    },
6414    ///    {
6415    ///      "type": "object",
6416    ///      "additionalProperties": {}
6417    ///    }
6418    ///  ]
6419    ///}
6420    /// ```
6421    /// </details>
6422    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6423    #[serde(untagged)]
6424    pub enum OptionsSetSftpValue {
6425        Variant0(::std::string::String),
6426        Variant1(f64),
6427        Variant2(i64),
6428        Variant3(bool),
6429        Variant4(::std::vec::Vec<::serde_json::Value>),
6430        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6431    }
6432
6433    impl ::std::convert::From<&Self> for OptionsSetSftpValue {
6434        fn from(value: &OptionsSetSftpValue) -> Self {
6435            value.clone()
6436        }
6437    }
6438
6439    impl ::std::convert::From<f64> for OptionsSetSftpValue {
6440        fn from(value: f64) -> Self {
6441            Self::Variant1(value)
6442        }
6443    }
6444
6445    impl ::std::convert::From<i64> for OptionsSetSftpValue {
6446        fn from(value: i64) -> Self {
6447            Self::Variant2(value)
6448        }
6449    }
6450
6451    impl ::std::convert::From<bool> for OptionsSetSftpValue {
6452        fn from(value: bool) -> Self {
6453            Self::Variant3(value)
6454        }
6455    }
6456
6457    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetSftpValue {
6458        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6459            Self::Variant4(value)
6460        }
6461    }
6462
6463    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6464        for OptionsSetSftpValue
6465    {
6466        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6467            Self::Variant5(value)
6468        }
6469    }
6470
6471    ///`OptionsSetVfsValue`
6472    ///
6473    /// <details><summary>JSON schema</summary>
6474    ///
6475    /// ```json
6476    ///{
6477    ///  "oneOf": [
6478    ///    {
6479    ///      "type": "string"
6480    ///    },
6481    ///    {
6482    ///      "type": "number"
6483    ///    },
6484    ///    {
6485    ///      "type": "integer"
6486    ///    },
6487    ///    {
6488    ///      "type": "boolean"
6489    ///    },
6490    ///    {
6491    ///      "type": "array",
6492    ///      "items": {}
6493    ///    },
6494    ///    {
6495    ///      "type": "object",
6496    ///      "additionalProperties": {}
6497    ///    }
6498    ///  ]
6499    ///}
6500    /// ```
6501    /// </details>
6502    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6503    #[serde(untagged)]
6504    pub enum OptionsSetVfsValue {
6505        Variant0(::std::string::String),
6506        Variant1(f64),
6507        Variant2(i64),
6508        Variant3(bool),
6509        Variant4(::std::vec::Vec<::serde_json::Value>),
6510        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6511    }
6512
6513    impl ::std::convert::From<&Self> for OptionsSetVfsValue {
6514        fn from(value: &OptionsSetVfsValue) -> Self {
6515            value.clone()
6516        }
6517    }
6518
6519    impl ::std::convert::From<f64> for OptionsSetVfsValue {
6520        fn from(value: f64) -> Self {
6521            Self::Variant1(value)
6522        }
6523    }
6524
6525    impl ::std::convert::From<i64> for OptionsSetVfsValue {
6526        fn from(value: i64) -> Self {
6527            Self::Variant2(value)
6528        }
6529    }
6530
6531    impl ::std::convert::From<bool> for OptionsSetVfsValue {
6532        fn from(value: bool) -> Self {
6533            Self::Variant3(value)
6534        }
6535    }
6536
6537    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetVfsValue {
6538        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6539            Self::Variant4(value)
6540        }
6541    }
6542
6543    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6544        for OptionsSetVfsValue
6545    {
6546        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6547            Self::Variant5(value)
6548        }
6549    }
6550
6551    ///`OptionsSetWebdavValue`
6552    ///
6553    /// <details><summary>JSON schema</summary>
6554    ///
6555    /// ```json
6556    ///{
6557    ///  "oneOf": [
6558    ///    {
6559    ///      "type": "string"
6560    ///    },
6561    ///    {
6562    ///      "type": "number"
6563    ///    },
6564    ///    {
6565    ///      "type": "integer"
6566    ///    },
6567    ///    {
6568    ///      "type": "boolean"
6569    ///    },
6570    ///    {
6571    ///      "type": "array",
6572    ///      "items": {}
6573    ///    },
6574    ///    {
6575    ///      "type": "object",
6576    ///      "additionalProperties": {}
6577    ///    }
6578    ///  ]
6579    ///}
6580    /// ```
6581    /// </details>
6582    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6583    #[serde(untagged)]
6584    pub enum OptionsSetWebdavValue {
6585        Variant0(::std::string::String),
6586        Variant1(f64),
6587        Variant2(i64),
6588        Variant3(bool),
6589        Variant4(::std::vec::Vec<::serde_json::Value>),
6590        Variant5(::serde_json::Map<::std::string::String, ::serde_json::Value>),
6591    }
6592
6593    impl ::std::convert::From<&Self> for OptionsSetWebdavValue {
6594        fn from(value: &OptionsSetWebdavValue) -> Self {
6595            value.clone()
6596        }
6597    }
6598
6599    impl ::std::convert::From<f64> for OptionsSetWebdavValue {
6600        fn from(value: f64) -> Self {
6601            Self::Variant1(value)
6602        }
6603    }
6604
6605    impl ::std::convert::From<i64> for OptionsSetWebdavValue {
6606        fn from(value: i64) -> Self {
6607            Self::Variant2(value)
6608        }
6609    }
6610
6611    impl ::std::convert::From<bool> for OptionsSetWebdavValue {
6612        fn from(value: bool) -> Self {
6613            Self::Variant3(value)
6614        }
6615    }
6616
6617    impl ::std::convert::From<::std::vec::Vec<::serde_json::Value>> for OptionsSetWebdavValue {
6618        fn from(value: ::std::vec::Vec<::serde_json::Value>) -> Self {
6619            Self::Variant4(value)
6620        }
6621    }
6622
6623    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
6624        for OptionsSetWebdavValue
6625    {
6626        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
6627            Self::Variant5(value)
6628        }
6629    }
6630
6631    ///`PluginsctlGetPluginsForTypeResponse`
6632    ///
6633    /// <details><summary>JSON schema</summary>
6634    ///
6635    /// ```json
6636    ///{
6637    ///  "type": "object",
6638    ///  "required": [
6639    ///    "loadedPlugins",
6640    ///    "loadedTestPlugins"
6641    ///  ],
6642    ///  "properties": {
6643    ///    "loadedPlugins": {
6644    ///      "description": "Installed plugins keyed by repository name.",
6645    ///      "type": "object",
6646    ///      "additionalProperties": {
6647    ///        "type": "object",
6648    ///        "additionalProperties": true
6649    ///      }
6650    ///    },
6651    ///    "loadedTestPlugins": {
6652    ///      "description": "Installed test plugins keyed by repository name.",
6653    ///      "type": "object",
6654    ///      "additionalProperties": {
6655    ///        "type": "object",
6656    ///        "additionalProperties": true
6657    ///      }
6658    ///    }
6659    ///  }
6660    ///}
6661    /// ```
6662    /// </details>
6663    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6664    pub struct PluginsctlGetPluginsForTypeResponse {
6665        ///Installed plugins keyed by repository name.
6666        #[serde(rename = "loadedPlugins")]
6667        pub loaded_plugins: ::std::collections::HashMap<
6668            ::std::string::String,
6669            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6670        >,
6671        ///Installed test plugins keyed by repository name.
6672        #[serde(rename = "loadedTestPlugins")]
6673        pub loaded_test_plugins: ::std::collections::HashMap<
6674            ::std::string::String,
6675            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6676        >,
6677    }
6678
6679    impl ::std::convert::From<&PluginsctlGetPluginsForTypeResponse>
6680        for PluginsctlGetPluginsForTypeResponse
6681    {
6682        fn from(value: &PluginsctlGetPluginsForTypeResponse) -> Self {
6683            value.clone()
6684        }
6685    }
6686
6687    ///`PluginsctlListPluginsResponse`
6688    ///
6689    /// <details><summary>JSON schema</summary>
6690    ///
6691    /// ```json
6692    ///{
6693    ///  "type": "object",
6694    ///  "required": [
6695    ///    "loadedPlugins",
6696    ///    "testPlugins"
6697    ///  ],
6698    ///  "properties": {
6699    ///    "loadedPlugins": {
6700    ///      "description": "Metadata entries for installed plugins.",
6701    ///      "type": "array",
6702    ///      "items": {
6703    ///        "type": "object",
6704    ///        "additionalProperties": true
6705    ///      }
6706    ///    },
6707    ///    "testPlugins": {
6708    ///      "description": "Metadata entries for installed test plugins.",
6709    ///      "type": "array",
6710    ///      "items": {
6711    ///        "type": "object",
6712    ///        "additionalProperties": true
6713    ///      }
6714    ///    }
6715    ///  }
6716    ///}
6717    /// ```
6718    /// </details>
6719    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6720    pub struct PluginsctlListPluginsResponse {
6721        ///Metadata entries for installed plugins.
6722        #[serde(rename = "loadedPlugins")]
6723        pub loaded_plugins:
6724            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6725        ///Metadata entries for installed test plugins.
6726        #[serde(rename = "testPlugins")]
6727        pub test_plugins:
6728            ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6729    }
6730
6731    impl ::std::convert::From<&PluginsctlListPluginsResponse> for PluginsctlListPluginsResponse {
6732        fn from(value: &PluginsctlListPluginsResponse) -> Self {
6733            value.clone()
6734        }
6735    }
6736
6737    ///`PluginsctlListTestPluginsResponse`
6738    ///
6739    /// <details><summary>JSON schema</summary>
6740    ///
6741    /// ```json
6742    ///{
6743    ///  "type": "object",
6744    ///  "required": [
6745    ///    "loadedTestPlugins"
6746    ///  ],
6747    ///  "properties": {
6748    ///    "loadedTestPlugins": {
6749    ///      "description": "Installed test plugin metadata keyed by
6750    /// repository.",
6751    ///      "type": "object",
6752    ///      "additionalProperties": {
6753    ///        "type": "object",
6754    ///        "additionalProperties": true
6755    ///      }
6756    ///    }
6757    ///  }
6758    ///}
6759    /// ```
6760    /// </details>
6761    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6762    pub struct PluginsctlListTestPluginsResponse {
6763        ///Installed test plugin metadata keyed by repository.
6764        #[serde(rename = "loadedTestPlugins")]
6765        pub loaded_test_plugins: ::std::collections::HashMap<
6766            ::std::string::String,
6767            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
6768        >,
6769    }
6770
6771    impl ::std::convert::From<&PluginsctlListTestPluginsResponse>
6772        for PluginsctlListTestPluginsResponse
6773    {
6774        fn from(value: &PluginsctlListTestPluginsResponse) -> Self {
6775            value.clone()
6776        }
6777    }
6778
6779    ///`RcError`
6780    ///
6781    /// <details><summary>JSON schema</summary>
6782    ///
6783    /// ```json
6784    ///{
6785    ///  "type": "object",
6786    ///  "required": [
6787    ///    "error",
6788    ///    "input",
6789    ///    "path",
6790    ///    "status"
6791    ///  ],
6792    ///  "properties": {
6793    ///    "error": {
6794    ///      "type": "string"
6795    ///    },
6796    ///    "input": {
6797    ///      "description": "Original request parameters echoed for debugging.",
6798    ///      "type": [
6799    ///        "object",
6800    ///        "null"
6801    ///      ],
6802    ///      "additionalProperties": {}
6803    ///    },
6804    ///    "path": {
6805    ///      "type": "string"
6806    ///    },
6807    ///    "status": {
6808    ///      "type": "integer"
6809    ///    }
6810    ///  }
6811    ///}
6812    /// ```
6813    /// </details>
6814    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6815    pub struct RcError {
6816        pub error: ::std::string::String,
6817        ///Original request parameters echoed for debugging.
6818        pub input:
6819            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
6820        pub path: ::std::string::String,
6821        pub status: i64,
6822    }
6823
6824    impl ::std::convert::From<&RcError> for RcError {
6825        fn from(value: &RcError) -> Self {
6826            value.clone()
6827        }
6828    }
6829
6830    ///`RcListResponse`
6831    ///
6832    /// <details><summary>JSON schema</summary>
6833    ///
6834    /// ```json
6835    ///{
6836    ///  "type": "object",
6837    ///  "required": [
6838    ///    "commands"
6839    ///  ],
6840    ///  "properties": {
6841    ///    "commands": {
6842    ///      "type": "array",
6843    ///      "items": {
6844    ///        "type": "object",
6845    ///        "properties": {
6846    ///          "AuthRequired": {
6847    ///            "type": "boolean"
6848    ///          },
6849    ///          "Help": {
6850    ///            "type": "string"
6851    ///          },
6852    ///          "NeedsRequest": {
6853    ///            "type": "boolean"
6854    ///          },
6855    ///          "NeedsResponse": {
6856    ///            "type": "boolean"
6857    ///          },
6858    ///          "Path": {
6859    ///            "type": "string"
6860    ///          },
6861    ///          "Title": {
6862    ///            "type": "string"
6863    ///          }
6864    ///        },
6865    ///        "additionalProperties": true
6866    ///      }
6867    ///    }
6868    ///  }
6869    ///}
6870    /// ```
6871    /// </details>
6872    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6873    pub struct RcListResponse {
6874        pub commands: ::std::vec::Vec<RcListResponseCommandsItem>,
6875    }
6876
6877    impl ::std::convert::From<&RcListResponse> for RcListResponse {
6878        fn from(value: &RcListResponse) -> Self {
6879            value.clone()
6880        }
6881    }
6882
6883    ///`RcListResponseCommandsItem`
6884    ///
6885    /// <details><summary>JSON schema</summary>
6886    ///
6887    /// ```json
6888    ///{
6889    ///  "type": "object",
6890    ///  "properties": {
6891    ///    "AuthRequired": {
6892    ///      "type": "boolean"
6893    ///    },
6894    ///    "Help": {
6895    ///      "type": "string"
6896    ///    },
6897    ///    "NeedsRequest": {
6898    ///      "type": "boolean"
6899    ///    },
6900    ///    "NeedsResponse": {
6901    ///      "type": "boolean"
6902    ///    },
6903    ///    "Path": {
6904    ///      "type": "string"
6905    ///    },
6906    ///    "Title": {
6907    ///      "type": "string"
6908    ///    }
6909    ///  },
6910    ///  "additionalProperties": true
6911    ///}
6912    /// ```
6913    /// </details>
6914    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6915    pub struct RcListResponseCommandsItem {
6916        #[serde(
6917            rename = "AuthRequired",
6918            default,
6919            skip_serializing_if = "::std::option::Option::is_none"
6920        )]
6921        pub auth_required: ::std::option::Option<bool>,
6922        #[serde(
6923            rename = "Help",
6924            default,
6925            skip_serializing_if = "::std::option::Option::is_none"
6926        )]
6927        pub help: ::std::option::Option<::std::string::String>,
6928        #[serde(
6929            rename = "NeedsRequest",
6930            default,
6931            skip_serializing_if = "::std::option::Option::is_none"
6932        )]
6933        pub needs_request: ::std::option::Option<bool>,
6934        #[serde(
6935            rename = "NeedsResponse",
6936            default,
6937            skip_serializing_if = "::std::option::Option::is_none"
6938        )]
6939        pub needs_response: ::std::option::Option<bool>,
6940        #[serde(
6941            rename = "Path",
6942            default,
6943            skip_serializing_if = "::std::option::Option::is_none"
6944        )]
6945        pub path: ::std::option::Option<::std::string::String>,
6946        #[serde(
6947            rename = "Title",
6948            default,
6949            skip_serializing_if = "::std::option::Option::is_none"
6950        )]
6951        pub title: ::std::option::Option<::std::string::String>,
6952    }
6953
6954    impl ::std::convert::From<&RcListResponseCommandsItem> for RcListResponseCommandsItem {
6955        fn from(value: &RcListResponseCommandsItem) -> Self {
6956            value.clone()
6957        }
6958    }
6959
6960    impl ::std::default::Default for RcListResponseCommandsItem {
6961        fn default() -> Self {
6962            Self {
6963                auth_required: Default::default(),
6964                help: Default::default(),
6965                needs_request: Default::default(),
6966                needs_response: Default::default(),
6967                path: Default::default(),
6968                title: Default::default(),
6969            }
6970        }
6971    }
6972
6973    ///`ServeListResponse`
6974    ///
6975    /// <details><summary>JSON schema</summary>
6976    ///
6977    /// ```json
6978    ///{
6979    ///  "type": "object",
6980    ///  "required": [
6981    ///    "list"
6982    ///  ],
6983    ///  "properties": {
6984    ///    "list": {
6985    ///      "type": "array",
6986    ///      "items": {
6987    ///        "type": "object",
6988    ///        "required": [
6989    ///          "addr",
6990    ///          "id"
6991    ///        ],
6992    ///        "properties": {
6993    ///          "addr": {
6994    ///            "description": "Address and port the server is listening
6995    /// on.",
6996    ///            "type": "string"
6997    ///          },
6998    ///          "id": {
6999    ///            "description": "Identifier returned by `serve/start`.",
7000    ///            "type": "string"
7001    ///          },
7002    ///          "params": {
7003    ///            "description": "Serve configuration parameters supplied at
7004    /// startup.",
7005    ///            "type": "object",
7006    ///            "required": [
7007    ///              "fs",
7008    ///              "id",
7009    ///              "type"
7010    ///            ],
7011    ///            "properties": {
7012    ///              "fs": {
7013    ///                "type": "string"
7014    ///              },
7015    ///              "opt": {
7016    ///                "type": "object",
7017    ///                "additionalProperties": true
7018    ///              },
7019    ///              "type": {
7020    ///                "type": "string"
7021    ///              },
7022    ///              "vfsOpt": {
7023    ///                "type": "object",
7024    ///                "additionalProperties": true
7025    ///              }
7026    ///            },
7027    ///            "additionalProperties": true
7028    ///          }
7029    ///        },
7030    ///        "additionalProperties": false
7031    ///      }
7032    ///    }
7033    ///  }
7034    ///}
7035    /// ```
7036    /// </details>
7037    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7038    pub struct ServeListResponse {
7039        pub list: ::std::vec::Vec<ServeListResponseListItem>,
7040    }
7041
7042    impl ::std::convert::From<&ServeListResponse> for ServeListResponse {
7043        fn from(value: &ServeListResponse) -> Self {
7044            value.clone()
7045        }
7046    }
7047
7048    ///`ServeListResponseListItem`
7049    ///
7050    /// <details><summary>JSON schema</summary>
7051    ///
7052    /// ```json
7053    ///{
7054    ///  "type": "object",
7055    ///  "required": [
7056    ///    "addr",
7057    ///    "id"
7058    ///  ],
7059    ///  "properties": {
7060    ///    "addr": {
7061    ///      "description": "Address and port the server is listening on.",
7062    ///      "type": "string"
7063    ///    },
7064    ///    "id": {
7065    ///      "description": "Identifier returned by `serve/start`.",
7066    ///      "type": "string"
7067    ///    },
7068    ///    "params": {
7069    ///      "description": "Serve configuration parameters supplied at
7070    /// startup.",
7071    ///      "type": "object",
7072    ///      "required": [
7073    ///        "fs",
7074    ///        "id",
7075    ///        "type"
7076    ///      ],
7077    ///      "properties": {
7078    ///        "fs": {
7079    ///          "type": "string"
7080    ///        },
7081    ///        "opt": {
7082    ///          "type": "object",
7083    ///          "additionalProperties": true
7084    ///        },
7085    ///        "type": {
7086    ///          "type": "string"
7087    ///        },
7088    ///        "vfsOpt": {
7089    ///          "type": "object",
7090    ///          "additionalProperties": true
7091    ///        }
7092    ///      },
7093    ///      "additionalProperties": true
7094    ///    }
7095    ///  },
7096    ///  "additionalProperties": false
7097    ///}
7098    /// ```
7099    /// </details>
7100    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7101    #[serde(deny_unknown_fields)]
7102    pub struct ServeListResponseListItem {
7103        ///Address and port the server is listening on.
7104        pub addr: ::std::string::String,
7105        ///Identifier returned by `serve/start`.
7106        pub id: ::std::string::String,
7107        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7108        pub params: ::std::option::Option<ServeListResponseListItemParams>,
7109    }
7110
7111    impl ::std::convert::From<&ServeListResponseListItem> for ServeListResponseListItem {
7112        fn from(value: &ServeListResponseListItem) -> Self {
7113            value.clone()
7114        }
7115    }
7116
7117    ///Serve configuration parameters supplied at startup.
7118    ///
7119    /// <details><summary>JSON schema</summary>
7120    ///
7121    /// ```json
7122    ///{
7123    ///  "description": "Serve configuration parameters supplied at startup.",
7124    ///  "type": "object",
7125    ///  "required": [
7126    ///    "fs",
7127    ///    "id",
7128    ///    "type"
7129    ///  ],
7130    ///  "properties": {
7131    ///    "fs": {
7132    ///      "type": "string"
7133    ///    },
7134    ///    "opt": {
7135    ///      "type": "object",
7136    ///      "additionalProperties": true
7137    ///    },
7138    ///    "type": {
7139    ///      "type": "string"
7140    ///    },
7141    ///    "vfsOpt": {
7142    ///      "type": "object",
7143    ///      "additionalProperties": true
7144    ///    }
7145    ///  },
7146    ///  "additionalProperties": true
7147    ///}
7148    /// ```
7149    /// </details>
7150    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7151    pub struct ServeListResponseListItemParams {
7152        pub fs: ::std::string::String,
7153        pub id: ::serde_json::Value,
7154        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
7155        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7156        #[serde(rename = "type")]
7157        pub type_: ::std::string::String,
7158        #[serde(
7159            rename = "vfsOpt",
7160            default,
7161            skip_serializing_if = "::serde_json::Map::is_empty"
7162        )]
7163        pub vfs_opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7164    }
7165
7166    impl ::std::convert::From<&ServeListResponseListItemParams> for ServeListResponseListItemParams {
7167        fn from(value: &ServeListResponseListItemParams) -> Self {
7168            value.clone()
7169        }
7170    }
7171
7172    ///`ServeStartResponse`
7173    ///
7174    /// <details><summary>JSON schema</summary>
7175    ///
7176    /// ```json
7177    ///{
7178    ///  "type": "object",
7179    ///  "required": [
7180    ///    "addr",
7181    ///    "id"
7182    ///  ],
7183    ///  "properties": {
7184    ///    "addr": {
7185    ///      "description": "Address and port the server is listening on.",
7186    ///      "type": "string"
7187    ///    },
7188    ///    "id": {
7189    ///      "description": "Identifier to pass to `serve/stop`.",
7190    ///      "type": "string"
7191    ///    }
7192    ///  }
7193    ///}
7194    /// ```
7195    /// </details>
7196    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7197    pub struct ServeStartResponse {
7198        ///Address and port the server is listening on.
7199        pub addr: ::std::string::String,
7200        ///Identifier to pass to `serve/stop`.
7201        pub id: ::std::string::String,
7202    }
7203
7204    impl ::std::convert::From<&ServeStartResponse> for ServeStartResponse {
7205        fn from(value: &ServeStartResponse) -> Self {
7206            value.clone()
7207        }
7208    }
7209
7210    ///`VfsForgetResponse`
7211    ///
7212    /// <details><summary>JSON schema</summary>
7213    ///
7214    /// ```json
7215    ///{
7216    ///  "type": "object",
7217    ///  "required": [
7218    ///    "forgotten"
7219    ///  ],
7220    ///  "properties": {
7221    ///    "forgotten": {
7222    ///      "description": "Paths that were successfully forgotten.",
7223    ///      "type": "array",
7224    ///      "items": {
7225    ///        "type": "string"
7226    ///      }
7227    ///    }
7228    ///  }
7229    ///}
7230    /// ```
7231    /// </details>
7232    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7233    pub struct VfsForgetResponse {
7234        ///Paths that were successfully forgotten.
7235        pub forgotten: ::std::vec::Vec<::std::string::String>,
7236    }
7237
7238    impl ::std::convert::From<&VfsForgetResponse> for VfsForgetResponse {
7239        fn from(value: &VfsForgetResponse) -> Self {
7240            value.clone()
7241        }
7242    }
7243
7244    ///`VfsListResponse`
7245    ///
7246    /// <details><summary>JSON schema</summary>
7247    ///
7248    /// ```json
7249    ///{
7250    ///  "type": "object",
7251    ///  "required": [
7252    ///    "vfses"
7253    ///  ],
7254    ///  "properties": {
7255    ///    "vfses": {
7256    ///      "description": "VFS name that can be used with other VFS
7257    /// endpoints.",
7258    ///      "type": "array",
7259    ///      "items": {
7260    ///        "type": "string"
7261    ///      }
7262    ///    }
7263    ///  }
7264    ///}
7265    /// ```
7266    /// </details>
7267    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7268    pub struct VfsListResponse {
7269        ///VFS name that can be used with other VFS endpoints.
7270        pub vfses: ::std::vec::Vec<::std::string::String>,
7271    }
7272
7273    impl ::std::convert::From<&VfsListResponse> for VfsListResponse {
7274        fn from(value: &VfsListResponse) -> Self {
7275            value.clone()
7276        }
7277    }
7278
7279    ///`VfsQueueResponse`
7280    ///
7281    /// <details><summary>JSON schema</summary>
7282    ///
7283    /// ```json
7284    ///{
7285    ///  "type": "object",
7286    ///  "properties": {
7287    ///    "queued": {
7288    ///      "type": "array",
7289    ///      "items": {
7290    ///        "description": "Queued item metadata such as name, size, expiry,
7291    /// and upload state.",
7292    ///        "type": "object",
7293    ///        "additionalProperties": true
7294    ///      }
7295    ///    }
7296    ///  }
7297    ///}
7298    /// ```
7299    /// </details>
7300    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7301    pub struct VfsQueueResponse {
7302        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7303        pub queued: ::std::vec::Vec<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7304    }
7305
7306    impl ::std::convert::From<&VfsQueueResponse> for VfsQueueResponse {
7307        fn from(value: &VfsQueueResponse) -> Self {
7308            value.clone()
7309        }
7310    }
7311
7312    impl ::std::default::Default for VfsQueueResponse {
7313        fn default() -> Self {
7314            Self {
7315                queued: Default::default(),
7316            }
7317        }
7318    }
7319
7320    ///`VfsRefreshResponse`
7321    ///
7322    /// <details><summary>JSON schema</summary>
7323    ///
7324    /// ```json
7325    ///{
7326    ///  "type": "object",
7327    ///  "required": [
7328    ///    "result"
7329    ///  ],
7330    ///  "properties": {
7331    ///    "result": {
7332    ///      "description": "Map of refreshed directories to status messages.",
7333    ///      "type": "object",
7334    ///      "additionalProperties": {
7335    ///        "type": "string"
7336    ///      }
7337    ///    }
7338    ///  }
7339    ///}
7340    /// ```
7341    /// </details>
7342    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7343    pub struct VfsRefreshResponse {
7344        ///Map of refreshed directories to status messages.
7345        pub result: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
7346    }
7347
7348    impl ::std::convert::From<&VfsRefreshResponse> for VfsRefreshResponse {
7349        fn from(value: &VfsRefreshResponse) -> Self {
7350            value.clone()
7351        }
7352    }
7353
7354    ///`VfsStatsResponse`
7355    ///
7356    /// <details><summary>JSON schema</summary>
7357    ///
7358    /// ```json
7359    ///{
7360    ///  "type": "object",
7361    ///  "required": [
7362    ///    "fs",
7363    ///    "inUse",
7364    ///    "metadataCache",
7365    ///    "opt"
7366    ///  ],
7367    ///  "properties": {
7368    ///    "diskCache": {
7369    ///      "description": "Disk cache metrics when caching is enabled.",
7370    ///      "type": [
7371    ///        "object",
7372    ///        "null"
7373    ///      ],
7374    ///      "additionalProperties": true
7375    ///    },
7376    ///    "fs": {
7377    ///      "description": "Name of the VFS.",
7378    ///      "type": "string"
7379    ///    },
7380    ///    "inUse": {
7381    ///      "description": "Number of active references to the VFS.",
7382    ///      "type": "integer"
7383    ///    },
7384    ///    "metadataCache": {
7385    ///      "description": "In-memory metadata cache counters.",
7386    ///      "type": "object",
7387    ///      "additionalProperties": {
7388    ///        "type": "integer"
7389    ///      }
7390    ///    },
7391    ///    "opt": {
7392    ///      "description": "Effective options applied to the VFS.",
7393    ///      "type": "object",
7394    ///      "additionalProperties": true
7395    ///    }
7396    ///  }
7397    ///}
7398    /// ```
7399    /// </details>
7400    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7401    pub struct VfsStatsResponse {
7402        ///Disk cache metrics when caching is enabled.
7403        #[serde(
7404            rename = "diskCache",
7405            default,
7406            skip_serializing_if = "::std::option::Option::is_none"
7407        )]
7408        pub disk_cache:
7409            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7410        ///Name of the VFS.
7411        pub fs: ::std::string::String,
7412        ///Number of active references to the VFS.
7413        #[serde(rename = "inUse")]
7414        pub in_use: i64,
7415        ///In-memory metadata cache counters.
7416        #[serde(rename = "metadataCache")]
7417        pub metadata_cache: ::std::collections::HashMap<::std::string::String, i64>,
7418        ///Effective options applied to the VFS.
7419        pub opt: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
7420    }
7421
7422    impl ::std::convert::From<&VfsStatsResponse> for VfsStatsResponse {
7423        fn from(value: &VfsStatsResponse) -> Self {
7424            value.clone()
7425        }
7426    }
7427}
7428
7429#[derive(Clone, Debug)]
7430///Client for Rclone RC API
7431///
7432///Full OpenAPI specification for the Rclone RC API.
7433///
7434///Version: 0.1.3
7435pub struct Client {
7436    pub(crate) baseurl: String,
7437    pub(crate) client: reqwest::Client,
7438}
7439
7440impl Client {
7441    /// Create a new client.
7442    ///
7443    /// `baseurl` is the base URL provided to the internal
7444    /// `reqwest::Client`, and should include a scheme and hostname,
7445    /// as well as port and a path stem if applicable.
7446    pub fn new(baseurl: &str) -> Self {
7447        #[cfg(not(target_arch = "wasm32"))]
7448        let client = {
7449            let dur = ::std::time::Duration::from_secs(15u64);
7450            reqwest::ClientBuilder::new()
7451                .connect_timeout(dur)
7452                .timeout(dur)
7453        };
7454        #[cfg(target_arch = "wasm32")]
7455        let client = reqwest::ClientBuilder::new();
7456        Self::new_with_client(baseurl, client.build().unwrap())
7457    }
7458
7459    /// Construct a new client with an existing `reqwest::Client`,
7460    /// allowing more control over its configuration.
7461    ///
7462    /// `baseurl` is the base URL provided to the internal
7463    /// `reqwest::Client`, and should include a scheme and hostname,
7464    /// as well as port and a path stem if applicable.
7465    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
7466        Self {
7467            baseurl: baseurl.to_string(),
7468            client,
7469        }
7470    }
7471}
7472
7473impl ClientInfo<()> for Client {
7474    fn api_version() -> &'static str {
7475        "0.1.3"
7476    }
7477
7478    fn baseurl(&self) -> &str {
7479        self.baseurl.as_str()
7480    }
7481
7482    fn client(&self) -> &reqwest::Client {
7483        &self.client
7484    }
7485
7486    fn inner(&self) -> &() {
7487        &()
7488    }
7489}
7490
7491impl ClientHooks<()> for &Client {}
7492#[allow(clippy::all)]
7493impl Client {
7494    ///Echo request parameters
7495    ///
7496    ///Returns all supplied parameters unchanged so you can verify RC
7497    /// connectivity.
7498    ///
7499    ///Sends a `POST` request to `/rc/noop`
7500    ///
7501    ///Arguments:
7502    /// - `async_`: Run the command asynchronously. Returns a job id
7503    ///   immediately.
7504    /// - `params`: Additional arbitrary parameters allowed.
7505    pub async fn rc_noop<'a>(
7506        &'a self,
7507        async_: Option<bool>,
7508        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7509    ) -> Result<
7510        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7511        Error<types::RcError>,
7512    > {
7513        let url = format!("{}/rc/noop", self.baseurl,);
7514        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7515        header_map.append(
7516            ::reqwest::header::HeaderName::from_static("api-version"),
7517            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7518        );
7519        #[allow(unused_mut)]
7520        let mut request = self
7521            .client
7522            .post(url)
7523            .header(
7524                ::reqwest::header::ACCEPT,
7525                ::reqwest::header::HeaderValue::from_static("application/json"),
7526            )
7527            .query(&progenitor_client::QueryParam::new("_async", &async_))
7528            .query(&progenitor_client::QueryParam::new("params", &params))
7529            .headers(header_map)
7530            .build()?;
7531        let info = OperationInfo {
7532            operation_id: "rc_noop",
7533        };
7534        self.pre(&mut request, &info).await?;
7535        let result = self.exec(request, &info).await;
7536        self.post(&result, &info).await?;
7537        let response = result?;
7538        match response.status().as_u16() {
7539            200u16 => ResponseValue::from_response(response).await,
7540            400u16..=499u16 => Err(Error::ErrorResponse(
7541                ResponseValue::from_response(response).await?,
7542            )),
7543            500u16..=599u16 => Err(Error::ErrorResponse(
7544                ResponseValue::from_response(response).await?,
7545            )),
7546            _ => Err(Error::UnexpectedResponse(response)),
7547        }
7548    }
7549
7550    ///Remove trashed files
7551    ///
7552    ///Permanently removes trashed objects from the specified remote path.
7553    ///
7554    ///Sends a `POST` request to `/operations/cleanup`
7555    ///
7556    ///Arguments:
7557    /// - `async_`: Run the command asynchronously. Returns a job id
7558    ///   immediately.
7559    /// - `group`: Assign the request to a custom stats group.
7560    /// - `fs`: Remote name or path to clean up, for example `drive:`.
7561    pub async fn operations_cleanup<'a>(
7562        &'a self,
7563        async_: Option<bool>,
7564        group: Option<&'a str>,
7565        fs: &'a str,
7566    ) -> Result<
7567        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7568        Error<types::RcError>,
7569    > {
7570        let url = format!("{}/operations/cleanup", self.baseurl,);
7571        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7572        header_map.append(
7573            ::reqwest::header::HeaderName::from_static("api-version"),
7574            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7575        );
7576        #[allow(unused_mut)]
7577        let mut request = self
7578            .client
7579            .post(url)
7580            .header(
7581                ::reqwest::header::ACCEPT,
7582                ::reqwest::header::HeaderValue::from_static("application/json"),
7583            )
7584            .query(&progenitor_client::QueryParam::new("_async", &async_))
7585            .query(&progenitor_client::QueryParam::new("_group", &group))
7586            .query(&progenitor_client::QueryParam::new("fs", &fs))
7587            .headers(header_map)
7588            .build()?;
7589        let info = OperationInfo {
7590            operation_id: "operations_cleanup",
7591        };
7592        self.pre(&mut request, &info).await?;
7593        let result = self.exec(request, &info).await;
7594        self.post(&result, &info).await?;
7595        let response = result?;
7596        match response.status().as_u16() {
7597            200u16 => ResponseValue::from_response(response).await,
7598            400u16..=499u16 => Err(Error::ErrorResponse(
7599                ResponseValue::from_response(response).await?,
7600            )),
7601            500u16..=599u16 => Err(Error::ErrorResponse(
7602                ResponseValue::from_response(response).await?,
7603            )),
7604            _ => Err(Error::UnexpectedResponse(response)),
7605        }
7606    }
7607
7608    ///Copy a single file
7609    ///
7610    ///Copies one object from a source remote and path to a destination remote
7611    /// and path.
7612    ///
7613    ///Sends a `POST` request to `/operations/copyfile`
7614    ///
7615    ///Arguments:
7616    /// - `async_`: Run the command asynchronously. Returns a job id
7617    ///   immediately.
7618    /// - `group`: Assign the request to a custom stats group.
7619    /// - `dst_fs`: Destination remote name or path, such as `drive2:` or `/`
7620    ///   for local filesystem.
7621    /// - `dst_remote`: Target path within `dstFs` where the file should be
7622    ///   written.
7623    /// - `src_fs`: Source remote name or path, such as `drive:` or `/` for the
7624    ///   local filesystem.
7625    /// - `src_remote`: Path to the source object within `srcFs`, for example
7626    ///   `dir/file.txt`.
7627    pub async fn operations_copyfile<'a>(
7628        &'a self,
7629        async_: Option<bool>,
7630        group: Option<&'a str>,
7631        dst_fs: &'a str,
7632        dst_remote: &'a str,
7633        src_fs: &'a str,
7634        src_remote: &'a str,
7635    ) -> Result<
7636        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7637        Error<types::RcError>,
7638    > {
7639        let url = format!("{}/operations/copyfile", self.baseurl,);
7640        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7641        header_map.append(
7642            ::reqwest::header::HeaderName::from_static("api-version"),
7643            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7644        );
7645        #[allow(unused_mut)]
7646        let mut request = self
7647            .client
7648            .post(url)
7649            .header(
7650                ::reqwest::header::ACCEPT,
7651                ::reqwest::header::HeaderValue::from_static("application/json"),
7652            )
7653            .query(&progenitor_client::QueryParam::new("_async", &async_))
7654            .query(&progenitor_client::QueryParam::new("_group", &group))
7655            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
7656            .query(&progenitor_client::QueryParam::new(
7657                "dstRemote",
7658                &dst_remote,
7659            ))
7660            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
7661            .query(&progenitor_client::QueryParam::new(
7662                "srcRemote",
7663                &src_remote,
7664            ))
7665            .headers(header_map)
7666            .build()?;
7667        let info = OperationInfo {
7668            operation_id: "operations_copyfile",
7669        };
7670        self.pre(&mut request, &info).await?;
7671        let result = self.exec(request, &info).await;
7672        self.post(&result, &info).await?;
7673        let response = result?;
7674        match response.status().as_u16() {
7675            200u16 => ResponseValue::from_response(response).await,
7676            400u16..=499u16 => Err(Error::ErrorResponse(
7677                ResponseValue::from_response(response).await?,
7678            )),
7679            500u16..=599u16 => Err(Error::ErrorResponse(
7680                ResponseValue::from_response(response).await?,
7681            )),
7682            _ => Err(Error::UnexpectedResponse(response)),
7683        }
7684    }
7685
7686    ///Copy from URL
7687    ///
7688    ///Downloads a public URL and stores it at the requested remote path.
7689    ///
7690    ///Sends a `POST` request to `/operations/copyurl`
7691    ///
7692    ///Arguments:
7693    /// - `async_`: Run the command asynchronously. Returns a job id
7694    ///   immediately.
7695    /// - `group`: Assign the request to a custom stats group.
7696    /// - `auto_filename`: Set to true to derive the destination filename from
7697    ///   the URL.
7698    /// - `fs`: Remote name or path that will receive the downloaded file, e.g.
7699    ///   `drive:`.
7700    /// - `remote`: Destination path within `fs` where the fetched object will
7701    ///   be stored.
7702    /// - `url`: Source URL to fetch the object from.
7703    pub async fn operations_copyurl<'a>(
7704        &'a self,
7705        async_: Option<bool>,
7706        group: Option<&'a str>,
7707        auto_filename: Option<bool>,
7708        fs: &'a str,
7709        remote: &'a str,
7710        url: &'a str,
7711    ) -> Result<
7712        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7713        Error<types::RcError>,
7714    > {
7715        let _url = format!("{}/operations/copyurl", self.baseurl,);
7716        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7717        header_map.append(
7718            ::reqwest::header::HeaderName::from_static("api-version"),
7719            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7720        );
7721        #[allow(unused_mut)]
7722        let mut request = self
7723            .client
7724            .post(_url)
7725            .header(
7726                ::reqwest::header::ACCEPT,
7727                ::reqwest::header::HeaderValue::from_static("application/json"),
7728            )
7729            .query(&progenitor_client::QueryParam::new("_async", &async_))
7730            .query(&progenitor_client::QueryParam::new("_group", &group))
7731            .query(&progenitor_client::QueryParam::new(
7732                "autoFilename",
7733                &auto_filename,
7734            ))
7735            .query(&progenitor_client::QueryParam::new("fs", &fs))
7736            .query(&progenitor_client::QueryParam::new("remote", &remote))
7737            .query(&progenitor_client::QueryParam::new("url", &url))
7738            .headers(header_map)
7739            .build()?;
7740        let info = OperationInfo {
7741            operation_id: "operations_copyurl",
7742        };
7743        self.pre(&mut request, &info).await?;
7744        let result = self.exec(request, &info).await;
7745        self.post(&result, &info).await?;
7746        let response = result?;
7747        match response.status().as_u16() {
7748            200u16 => ResponseValue::from_response(response).await,
7749            400u16..=499u16 => Err(Error::ErrorResponse(
7750                ResponseValue::from_response(response).await?,
7751            )),
7752            500u16..=599u16 => Err(Error::ErrorResponse(
7753                ResponseValue::from_response(response).await?,
7754            )),
7755            _ => Err(Error::UnexpectedResponse(response)),
7756        }
7757    }
7758
7759    ///Delete objects in path
7760    ///
7761    ///Deletes matching files and directories for the provided remote,
7762    /// honouring filters and config overrides.
7763    ///
7764    ///Sends a `POST` request to `/operations/delete`
7765    ///
7766    ///Arguments:
7767    /// - `async_`: Run the command asynchronously. Returns a job id
7768    ///   immediately.
7769    /// - `config`: JSON encoded config overrides applied for this call only.
7770    /// - `filter`: JSON encoded filter overrides applied for this call only.
7771    /// - `group`: Assign the request to a custom stats group.
7772    /// - `fs`: Remote name or path whose contents should be removed.
7773    pub async fn operations_delete<'a>(
7774        &'a self,
7775        async_: Option<bool>,
7776        config: Option<&'a str>,
7777        filter: Option<&'a str>,
7778        group: Option<&'a str>,
7779        fs: &'a str,
7780    ) -> Result<
7781        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7782        Error<types::RcError>,
7783    > {
7784        let url = format!("{}/operations/delete", self.baseurl,);
7785        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7786        header_map.append(
7787            ::reqwest::header::HeaderName::from_static("api-version"),
7788            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7789        );
7790        #[allow(unused_mut)]
7791        let mut request = self
7792            .client
7793            .post(url)
7794            .header(
7795                ::reqwest::header::ACCEPT,
7796                ::reqwest::header::HeaderValue::from_static("application/json"),
7797            )
7798            .query(&progenitor_client::QueryParam::new("_async", &async_))
7799            .query(&progenitor_client::QueryParam::new("_config", &config))
7800            .query(&progenitor_client::QueryParam::new("_filter", &filter))
7801            .query(&progenitor_client::QueryParam::new("_group", &group))
7802            .query(&progenitor_client::QueryParam::new("fs", &fs))
7803            .headers(header_map)
7804            .build()?;
7805        let info = OperationInfo {
7806            operation_id: "operations_delete",
7807        };
7808        self.pre(&mut request, &info).await?;
7809        let result = self.exec(request, &info).await;
7810        self.post(&result, &info).await?;
7811        let response = result?;
7812        match response.status().as_u16() {
7813            200u16 => ResponseValue::from_response(response).await,
7814            400u16..=499u16 => Err(Error::ErrorResponse(
7815                ResponseValue::from_response(response).await?,
7816            )),
7817            500u16..=599u16 => Err(Error::ErrorResponse(
7818                ResponseValue::from_response(response).await?,
7819            )),
7820            _ => Err(Error::UnexpectedResponse(response)),
7821        }
7822    }
7823
7824    ///Delete single file
7825    ///
7826    ///Removes a specific object from the remote.
7827    ///
7828    ///Sends a `POST` request to `/operations/deletefile`
7829    ///
7830    ///Arguments:
7831    /// - `async_`: Run the command asynchronously. Returns a job id
7832    ///   immediately.
7833    /// - `group`: Assign the request to a custom stats group.
7834    /// - `fs`: Remote name or path that contains the file to delete.
7835    /// - `remote`: Exact path to the file within `fs` that should be deleted.
7836    pub async fn operations_deletefile<'a>(
7837        &'a self,
7838        async_: Option<bool>,
7839        group: Option<&'a str>,
7840        fs: &'a str,
7841        remote: &'a str,
7842    ) -> Result<
7843        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
7844        Error<types::RcError>,
7845    > {
7846        let url = format!("{}/operations/deletefile", self.baseurl,);
7847        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7848        header_map.append(
7849            ::reqwest::header::HeaderName::from_static("api-version"),
7850            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7851        );
7852        #[allow(unused_mut)]
7853        let mut request = self
7854            .client
7855            .post(url)
7856            .header(
7857                ::reqwest::header::ACCEPT,
7858                ::reqwest::header::HeaderValue::from_static("application/json"),
7859            )
7860            .query(&progenitor_client::QueryParam::new("_async", &async_))
7861            .query(&progenitor_client::QueryParam::new("_group", &group))
7862            .query(&progenitor_client::QueryParam::new("fs", &fs))
7863            .query(&progenitor_client::QueryParam::new("remote", &remote))
7864            .headers(header_map)
7865            .build()?;
7866        let info = OperationInfo {
7867            operation_id: "operations_deletefile",
7868        };
7869        self.pre(&mut request, &info).await?;
7870        let result = self.exec(request, &info).await;
7871        self.post(&result, &info).await?;
7872        let response = result?;
7873        match response.status().as_u16() {
7874            200u16 => ResponseValue::from_response(response).await,
7875            400u16..=499u16 => Err(Error::ErrorResponse(
7876                ResponseValue::from_response(response).await?,
7877            )),
7878            500u16..=599u16 => Err(Error::ErrorResponse(
7879                ResponseValue::from_response(response).await?,
7880            )),
7881            _ => Err(Error::UnexpectedResponse(response)),
7882        }
7883    }
7884
7885    ///Describe remote capabilities
7886    ///
7887    ///Returns backend features, hash support, metadata descriptions, and other
7888    /// info for the remote.
7889    ///
7890    ///Sends a `POST` request to `/operations/fsinfo`
7891    ///
7892    ///Arguments:
7893    /// - `async_`: Run the command asynchronously. Returns a job id
7894    ///   immediately.
7895    /// - `group`: Assign the request to a custom stats group.
7896    /// - `fs`: Remote name or path to inspect, e.g. `drive:`.
7897    pub async fn operations_fsinfo<'a>(
7898        &'a self,
7899        async_: Option<bool>,
7900        group: Option<&'a str>,
7901        fs: &'a str,
7902    ) -> Result<ResponseValue<types::OperationsFsinfoResponse>, Error<types::RcError>> {
7903        let url = format!("{}/operations/fsinfo", self.baseurl,);
7904        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7905        header_map.append(
7906            ::reqwest::header::HeaderName::from_static("api-version"),
7907            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7908        );
7909        #[allow(unused_mut)]
7910        let mut request = self
7911            .client
7912            .post(url)
7913            .header(
7914                ::reqwest::header::ACCEPT,
7915                ::reqwest::header::HeaderValue::from_static("application/json"),
7916            )
7917            .query(&progenitor_client::QueryParam::new("_async", &async_))
7918            .query(&progenitor_client::QueryParam::new("_group", &group))
7919            .query(&progenitor_client::QueryParam::new("fs", &fs))
7920            .headers(header_map)
7921            .build()?;
7922        let info = OperationInfo {
7923            operation_id: "operations_fsinfo",
7924        };
7925        self.pre(&mut request, &info).await?;
7926        let result = self.exec(request, &info).await;
7927        self.post(&result, &info).await?;
7928        let response = result?;
7929        match response.status().as_u16() {
7930            200u16 => ResponseValue::from_response(response).await,
7931            400u16..=499u16 => Err(Error::ErrorResponse(
7932                ResponseValue::from_response(response).await?,
7933            )),
7934            500u16..=599u16 => Err(Error::ErrorResponse(
7935                ResponseValue::from_response(response).await?,
7936            )),
7937            _ => Err(Error::UnexpectedResponse(response)),
7938        }
7939    }
7940
7941    ///Generate hash sums
7942    ///
7943    ///Produces a hash sum listing for files under the given path using the
7944    /// requested hash algorithm.
7945    ///
7946    ///Sends a `POST` request to `/operations/hashsum`
7947    ///
7948    ///Arguments:
7949    /// - `async_`: Run the command asynchronously. Returns a job id
7950    ///   immediately.
7951    /// - `group`: Assign the request to a custom stats group.
7952    /// - `base64`: Set to true to emit hash values in base64 rather than
7953    ///   hexadecimal.
7954    /// - `download`: Set to true to force reading the data instead of using
7955    ///   remote checksums.
7956    /// - `fs`: Remote name or path to hash, such as `drive:` or `/`.
7957    /// - `hash_type`: Hash algorithm to use, e.g. `md5`, `sha1`, or another
7958    ///   supported name.
7959    pub async fn operations_hashsum<'a>(
7960        &'a self,
7961        async_: Option<bool>,
7962        group: Option<&'a str>,
7963        base64: Option<bool>,
7964        download: Option<bool>,
7965        fs: &'a str,
7966        hash_type: &'a str,
7967    ) -> Result<ResponseValue<types::OperationsHashsumResponse>, Error<types::RcError>> {
7968        let url = format!("{}/operations/hashsum", self.baseurl,);
7969        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
7970        header_map.append(
7971            ::reqwest::header::HeaderName::from_static("api-version"),
7972            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
7973        );
7974        #[allow(unused_mut)]
7975        let mut request = self
7976            .client
7977            .post(url)
7978            .header(
7979                ::reqwest::header::ACCEPT,
7980                ::reqwest::header::HeaderValue::from_static("application/json"),
7981            )
7982            .query(&progenitor_client::QueryParam::new("_async", &async_))
7983            .query(&progenitor_client::QueryParam::new("_group", &group))
7984            .query(&progenitor_client::QueryParam::new("base64", &base64))
7985            .query(&progenitor_client::QueryParam::new("download", &download))
7986            .query(&progenitor_client::QueryParam::new("fs", &fs))
7987            .query(&progenitor_client::QueryParam::new("hashType", &hash_type))
7988            .headers(header_map)
7989            .build()?;
7990        let info = OperationInfo {
7991            operation_id: "operations_hashsum",
7992        };
7993        self.pre(&mut request, &info).await?;
7994        let result = self.exec(request, &info).await;
7995        self.post(&result, &info).await?;
7996        let response = result?;
7997        match response.status().as_u16() {
7998            200u16 => ResponseValue::from_response(response).await,
7999            400u16..=499u16 => Err(Error::ErrorResponse(
8000                ResponseValue::from_response(response).await?,
8001            )),
8002            500u16..=599u16 => Err(Error::ErrorResponse(
8003                ResponseValue::from_response(response).await?,
8004            )),
8005            _ => Err(Error::UnexpectedResponse(response)),
8006        }
8007    }
8008
8009    ///Move a single file
8010    ///
8011    ///Moves one object from a source remote and path to a destination remote
8012    /// and path.
8013    ///
8014    ///Sends a `POST` request to `/operations/movefile`
8015    ///
8016    ///Arguments:
8017    /// - `async_`: Run the command asynchronously. Returns a job id
8018    ///   immediately.
8019    /// - `group`: Assign the request to a custom stats group.
8020    /// - `dst_fs`: Destination remote name or path where the file will be
8021    ///   moved.
8022    /// - `dst_remote`: Destination path within `dstFs` for the moved object.
8023    /// - `src_fs`: Source remote name or path containing the file to move.
8024    /// - `src_remote`: Path to the source object within `srcFs`.
8025    pub async fn operations_movefile<'a>(
8026        &'a self,
8027        async_: Option<bool>,
8028        group: Option<&'a str>,
8029        dst_fs: &'a str,
8030        dst_remote: &'a str,
8031        src_fs: &'a str,
8032        src_remote: &'a str,
8033    ) -> Result<
8034        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8035        Error<types::RcError>,
8036    > {
8037        let url = format!("{}/operations/movefile", self.baseurl,);
8038        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8039        header_map.append(
8040            ::reqwest::header::HeaderName::from_static("api-version"),
8041            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8042        );
8043        #[allow(unused_mut)]
8044        let mut request = self
8045            .client
8046            .post(url)
8047            .header(
8048                ::reqwest::header::ACCEPT,
8049                ::reqwest::header::HeaderValue::from_static("application/json"),
8050            )
8051            .query(&progenitor_client::QueryParam::new("_async", &async_))
8052            .query(&progenitor_client::QueryParam::new("_group", &group))
8053            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
8054            .query(&progenitor_client::QueryParam::new(
8055                "dstRemote",
8056                &dst_remote,
8057            ))
8058            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
8059            .query(&progenitor_client::QueryParam::new(
8060                "srcRemote",
8061                &src_remote,
8062            ))
8063            .headers(header_map)
8064            .build()?;
8065        let info = OperationInfo {
8066            operation_id: "operations_movefile",
8067        };
8068        self.pre(&mut request, &info).await?;
8069        let result = self.exec(request, &info).await;
8070        self.post(&result, &info).await?;
8071        let response = result?;
8072        match response.status().as_u16() {
8073            200u16 => ResponseValue::from_response(response).await,
8074            400u16..=499u16 => Err(Error::ErrorResponse(
8075                ResponseValue::from_response(response).await?,
8076            )),
8077            500u16..=599u16 => Err(Error::ErrorResponse(
8078                ResponseValue::from_response(response).await?,
8079            )),
8080            _ => Err(Error::UnexpectedResponse(response)),
8081        }
8082    }
8083
8084    ///Create or remove public link
8085    ///
8086    ///Creates a share URL for an object or removes an existing link when
8087    /// `unlink=true`.
8088    ///
8089    ///Sends a `POST` request to `/operations/publiclink`
8090    ///
8091    ///Arguments:
8092    /// - `async_`: Run the command asynchronously. Returns a job id
8093    ///   immediately.
8094    /// - `group`: Assign the request to a custom stats group.
8095    /// - `expire`: Optional expiration time for the public link, formatted as
8096    ///   supported by the backend.
8097    /// - `fs`: Remote name or path hosting the object for which to manage a
8098    ///   public link.
8099    /// - `remote`: Path within `fs` to the object for which to create or remove
8100    ///   a public link.
8101    /// - `unlink`: Set to true to remove an existing public link instead of
8102    ///   creating one.
8103    pub async fn operations_publiclink<'a>(
8104        &'a self,
8105        async_: Option<bool>,
8106        group: Option<&'a str>,
8107        expire: Option<&'a str>,
8108        fs: &'a str,
8109        remote: &'a str,
8110        unlink: Option<bool>,
8111    ) -> Result<ResponseValue<types::OperationsPubliclinkResponse>, Error<types::RcError>> {
8112        let url = format!("{}/operations/publiclink", self.baseurl,);
8113        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8114        header_map.append(
8115            ::reqwest::header::HeaderName::from_static("api-version"),
8116            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8117        );
8118        #[allow(unused_mut)]
8119        let mut request = self
8120            .client
8121            .post(url)
8122            .header(
8123                ::reqwest::header::ACCEPT,
8124                ::reqwest::header::HeaderValue::from_static("application/json"),
8125            )
8126            .query(&progenitor_client::QueryParam::new("_async", &async_))
8127            .query(&progenitor_client::QueryParam::new("_group", &group))
8128            .query(&progenitor_client::QueryParam::new("expire", &expire))
8129            .query(&progenitor_client::QueryParam::new("fs", &fs))
8130            .query(&progenitor_client::QueryParam::new("remote", &remote))
8131            .query(&progenitor_client::QueryParam::new("unlink", &unlink))
8132            .headers(header_map)
8133            .build()?;
8134        let info = OperationInfo {
8135            operation_id: "operations_publiclink",
8136        };
8137        self.pre(&mut request, &info).await?;
8138        let result = self.exec(request, &info).await;
8139        self.post(&result, &info).await?;
8140        let response = result?;
8141        match response.status().as_u16() {
8142            200u16 => ResponseValue::from_response(response).await,
8143            400u16..=499u16 => Err(Error::ErrorResponse(
8144                ResponseValue::from_response(response).await?,
8145            )),
8146            500u16..=599u16 => Err(Error::ErrorResponse(
8147                ResponseValue::from_response(response).await?,
8148            )),
8149            _ => Err(Error::UnexpectedResponse(response)),
8150        }
8151    }
8152
8153    ///Remove empty directories
8154    ///
8155    ///Deletes empty subdirectories beneath the specified path, optionally
8156    /// leaving the root.
8157    ///
8158    ///Sends a `POST` request to `/operations/rmdirs`
8159    ///
8160    ///Arguments:
8161    /// - `async_`: Run the command asynchronously. Returns a job id
8162    ///   immediately.
8163    /// - `group`: Assign the request to a custom stats group.
8164    /// - `fs`: Remote name or path to scan for empty directories.
8165    /// - `leave_root`: Set to true to preserve the top-level directory even if
8166    ///   empty.
8167    /// - `remote`: Path within `fs` whose empty subdirectories should be
8168    ///   removed.
8169    pub async fn operations_rmdirs<'a>(
8170        &'a self,
8171        async_: Option<bool>,
8172        group: Option<&'a str>,
8173        fs: &'a str,
8174        leave_root: Option<bool>,
8175        remote: &'a str,
8176    ) -> Result<
8177        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8178        Error<types::RcError>,
8179    > {
8180        let url = format!("{}/operations/rmdirs", self.baseurl,);
8181        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8182        header_map.append(
8183            ::reqwest::header::HeaderName::from_static("api-version"),
8184            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8185        );
8186        #[allow(unused_mut)]
8187        let mut request = self
8188            .client
8189            .post(url)
8190            .header(
8191                ::reqwest::header::ACCEPT,
8192                ::reqwest::header::HeaderValue::from_static("application/json"),
8193            )
8194            .query(&progenitor_client::QueryParam::new("_async", &async_))
8195            .query(&progenitor_client::QueryParam::new("_group", &group))
8196            .query(&progenitor_client::QueryParam::new("fs", &fs))
8197            .query(&progenitor_client::QueryParam::new(
8198                "leaveRoot",
8199                &leave_root,
8200            ))
8201            .query(&progenitor_client::QueryParam::new("remote", &remote))
8202            .headers(header_map)
8203            .build()?;
8204        let info = OperationInfo {
8205            operation_id: "operations_rmdirs",
8206        };
8207        self.pre(&mut request, &info).await?;
8208        let result = self.exec(request, &info).await;
8209        self.post(&result, &info).await?;
8210        let response = result?;
8211        match response.status().as_u16() {
8212            200u16 => ResponseValue::from_response(response).await,
8213            400u16..=499u16 => Err(Error::ErrorResponse(
8214                ResponseValue::from_response(response).await?,
8215            )),
8216            500u16..=599u16 => Err(Error::ErrorResponse(
8217                ResponseValue::from_response(response).await?,
8218            )),
8219            _ => Err(Error::UnexpectedResponse(response)),
8220        }
8221    }
8222
8223    ///Change storage tier
8224    ///
8225    ///Updates the storage class or tier for every object in the specified
8226    /// remote path.
8227    ///
8228    ///Sends a `POST` request to `/operations/settier`
8229    ///
8230    ///Arguments:
8231    /// - `async_`: Run the command asynchronously. Returns a job id
8232    ///   immediately.
8233    /// - `group`: Assign the request to a custom stats group.
8234    /// - `fs`: Remote name or path whose storage class tier should be changed.
8235    pub async fn operations_settier<'a>(
8236        &'a self,
8237        async_: Option<bool>,
8238        group: Option<&'a str>,
8239        fs: &'a str,
8240    ) -> Result<
8241        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8242        Error<types::RcError>,
8243    > {
8244        let url = format!("{}/operations/settier", self.baseurl,);
8245        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8246        header_map.append(
8247            ::reqwest::header::HeaderName::from_static("api-version"),
8248            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8249        );
8250        #[allow(unused_mut)]
8251        let mut request = self
8252            .client
8253            .post(url)
8254            .header(
8255                ::reqwest::header::ACCEPT,
8256                ::reqwest::header::HeaderValue::from_static("application/json"),
8257            )
8258            .query(&progenitor_client::QueryParam::new("_async", &async_))
8259            .query(&progenitor_client::QueryParam::new("_group", &group))
8260            .query(&progenitor_client::QueryParam::new("fs", &fs))
8261            .headers(header_map)
8262            .build()?;
8263        let info = OperationInfo {
8264            operation_id: "operations_settier",
8265        };
8266        self.pre(&mut request, &info).await?;
8267        let result = self.exec(request, &info).await;
8268        self.post(&result, &info).await?;
8269        let response = result?;
8270        match response.status().as_u16() {
8271            200u16 => ResponseValue::from_response(response).await,
8272            400u16..=499u16 => Err(Error::ErrorResponse(
8273                ResponseValue::from_response(response).await?,
8274            )),
8275            500u16..=599u16 => Err(Error::ErrorResponse(
8276                ResponseValue::from_response(response).await?,
8277            )),
8278            _ => Err(Error::UnexpectedResponse(response)),
8279        }
8280    }
8281
8282    ///Change file storage tier
8283    ///
8284    ///Updates the storage class or tier for a single object.
8285    ///
8286    ///Sends a `POST` request to `/operations/settierfile`
8287    ///
8288    ///Arguments:
8289    /// - `async_`: Run the command asynchronously. Returns a job id
8290    ///   immediately.
8291    /// - `group`: Assign the request to a custom stats group.
8292    /// - `fs`: Remote name or path that contains the object whose tier should
8293    ///   change.
8294    /// - `remote`: Path within `fs` to the object whose storage class tier
8295    ///   should be updated.
8296    pub async fn operations_settierfile<'a>(
8297        &'a self,
8298        async_: Option<bool>,
8299        group: Option<&'a str>,
8300        fs: &'a str,
8301        remote: &'a str,
8302    ) -> Result<
8303        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8304        Error<types::RcError>,
8305    > {
8306        let url = format!("{}/operations/settierfile", self.baseurl,);
8307        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8308        header_map.append(
8309            ::reqwest::header::HeaderName::from_static("api-version"),
8310            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8311        );
8312        #[allow(unused_mut)]
8313        let mut request = self
8314            .client
8315            .post(url)
8316            .header(
8317                ::reqwest::header::ACCEPT,
8318                ::reqwest::header::HeaderValue::from_static("application/json"),
8319            )
8320            .query(&progenitor_client::QueryParam::new("_async", &async_))
8321            .query(&progenitor_client::QueryParam::new("_group", &group))
8322            .query(&progenitor_client::QueryParam::new("fs", &fs))
8323            .query(&progenitor_client::QueryParam::new("remote", &remote))
8324            .headers(header_map)
8325            .build()?;
8326        let info = OperationInfo {
8327            operation_id: "operations_settierfile",
8328        };
8329        self.pre(&mut request, &info).await?;
8330        let result = self.exec(request, &info).await;
8331        self.post(&result, &info).await?;
8332        let response = result?;
8333        match response.status().as_u16() {
8334            200u16 => ResponseValue::from_response(response).await,
8335            400u16..=499u16 => Err(Error::ErrorResponse(
8336                ResponseValue::from_response(response).await?,
8337            )),
8338            500u16..=599u16 => Err(Error::ErrorResponse(
8339                ResponseValue::from_response(response).await?,
8340            )),
8341            _ => Err(Error::UnexpectedResponse(response)),
8342        }
8343    }
8344
8345    ///Count remote size
8346    ///
8347    ///Reports total size, file count, and number of objects without size
8348    /// metadata.
8349    ///
8350    ///Sends a `POST` request to `/operations/size`
8351    ///
8352    ///Arguments:
8353    /// - `async_`: Run the command asynchronously. Returns a job id
8354    ///   immediately.
8355    /// - `group`: Assign the request to a custom stats group.
8356    /// - `fs`: Remote name or path to measure aggregate size information for.
8357    pub async fn operations_size<'a>(
8358        &'a self,
8359        async_: Option<bool>,
8360        group: Option<&'a str>,
8361        fs: &'a str,
8362    ) -> Result<ResponseValue<types::OperationsSizeResponse>, Error<types::RcError>> {
8363        let url = format!("{}/operations/size", self.baseurl,);
8364        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8365        header_map.append(
8366            ::reqwest::header::HeaderName::from_static("api-version"),
8367            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8368        );
8369        #[allow(unused_mut)]
8370        let mut request = self
8371            .client
8372            .post(url)
8373            .header(
8374                ::reqwest::header::ACCEPT,
8375                ::reqwest::header::HeaderValue::from_static("application/json"),
8376            )
8377            .query(&progenitor_client::QueryParam::new("_async", &async_))
8378            .query(&progenitor_client::QueryParam::new("_group", &group))
8379            .query(&progenitor_client::QueryParam::new("fs", &fs))
8380            .headers(header_map)
8381            .build()?;
8382        let info = OperationInfo {
8383            operation_id: "operations_size",
8384        };
8385        self.pre(&mut request, &info).await?;
8386        let result = self.exec(request, &info).await;
8387        self.post(&result, &info).await?;
8388        let response = result?;
8389        match response.status().as_u16() {
8390            200u16 => ResponseValue::from_response(response).await,
8391            400u16..=499u16 => Err(Error::ErrorResponse(
8392                ResponseValue::from_response(response).await?,
8393            )),
8394            500u16..=599u16 => Err(Error::ErrorResponse(
8395                ResponseValue::from_response(response).await?,
8396            )),
8397            _ => Err(Error::UnexpectedResponse(response)),
8398        }
8399    }
8400
8401    ///Get or update bandwidth limits
8402    ///
8403    ///Reads the current bandwidth limit or applies a new schedule string, just
8404    /// like `rclone rc core/bwlimit`.
8405    ///
8406    ///Sends a `POST` request to `/core/bwlimit`
8407    ///
8408    ///Arguments:
8409    /// - `async_`: Run the command asynchronously. Returns a job id
8410    ///   immediately.
8411    /// - `group`: Assign the request to a custom stats group.
8412    /// - `rate`: Bandwidth limit to apply, for example `off`, `5M`, or a
8413    ///   schedule string.
8414    pub async fn core_bwlimit<'a>(
8415        &'a self,
8416        async_: Option<bool>,
8417        group: Option<&'a str>,
8418        rate: Option<&'a str>,
8419    ) -> Result<ResponseValue<types::CoreBwlimitResponse>, Error<types::RcError>> {
8420        let url = format!("{}/core/bwlimit", self.baseurl,);
8421        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8422        header_map.append(
8423            ::reqwest::header::HeaderName::from_static("api-version"),
8424            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8425        );
8426        #[allow(unused_mut)]
8427        let mut request = self
8428            .client
8429            .post(url)
8430            .header(
8431                ::reqwest::header::ACCEPT,
8432                ::reqwest::header::HeaderValue::from_static("application/json"),
8433            )
8434            .query(&progenitor_client::QueryParam::new("_async", &async_))
8435            .query(&progenitor_client::QueryParam::new("_group", &group))
8436            .query(&progenitor_client::QueryParam::new("rate", &rate))
8437            .headers(header_map)
8438            .build()?;
8439        let info = OperationInfo {
8440            operation_id: "core_bwlimit",
8441        };
8442        self.pre(&mut request, &info).await?;
8443        let result = self.exec(request, &info).await;
8444        self.post(&result, &info).await?;
8445        let response = result?;
8446        match response.status().as_u16() {
8447            200u16 => ResponseValue::from_response(response).await,
8448            400u16..=499u16 => Err(Error::ErrorResponse(
8449                ResponseValue::from_response(response).await?,
8450            )),
8451            500u16..=599u16 => Err(Error::ErrorResponse(
8452                ResponseValue::from_response(response).await?,
8453            )),
8454            _ => Err(Error::UnexpectedResponse(response)),
8455        }
8456    }
8457
8458    ///Run an rclone command
8459    ///
8460    ///Executes a standard rclone CLI command remotely and streams or returns
8461    /// its output.
8462    ///
8463    ///Sends a `POST` request to `/core/command`
8464    ///
8465    ///Arguments:
8466    /// - `async_`: Run the command asynchronously. Returns a job id
8467    ///   immediately.
8468    /// - `group`: Assign the request to a custom stats group.
8469    /// - `arg`: Optional positional arguments for the command. Repeat to supply
8470    ///   multiple values.
8471    /// - `command`: Name of the rclone command to execute, for example `ls` or
8472    ///   `lsf`.
8473    /// - `opt`: Optional command options encoded as a JSON string.
8474    /// - `return_type`: Controls how output is returned; accepts
8475    ///   `COMBINED_OUTPUT`, `STREAM`, `STREAM_ONLY_STDOUT`, or
8476    ///   `STREAM_ONLY_STDERR`.
8477    pub async fn core_command<'a>(
8478        &'a self,
8479        async_: Option<bool>,
8480        group: Option<&'a str>,
8481        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
8482        command: &'a str,
8483        opt: Option<&'a str>,
8484        return_type: Option<&'a str>,
8485    ) -> Result<ResponseValue<types::CoreCommandResponse>, Error<types::RcError>> {
8486        let url = format!("{}/core/command", self.baseurl,);
8487        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8488        header_map.append(
8489            ::reqwest::header::HeaderName::from_static("api-version"),
8490            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8491        );
8492        #[allow(unused_mut)]
8493        let mut request = self
8494            .client
8495            .post(url)
8496            .header(
8497                ::reqwest::header::ACCEPT,
8498                ::reqwest::header::HeaderValue::from_static("application/json"),
8499            )
8500            .query(&progenitor_client::QueryParam::new("_async", &async_))
8501            .query(&progenitor_client::QueryParam::new("_group", &group))
8502            .query(&progenitor_client::QueryParam::new("arg", &arg))
8503            .query(&progenitor_client::QueryParam::new("command", &command))
8504            .query(&progenitor_client::QueryParam::new("opt", &opt))
8505            .query(&progenitor_client::QueryParam::new(
8506                "returnType",
8507                &return_type,
8508            ))
8509            .headers(header_map)
8510            .build()?;
8511        let info = OperationInfo {
8512            operation_id: "core_command",
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    ///Report disk usage
8531    ///
8532    ///Returns disk usage statistics for the supplied local directory (defaults
8533    /// to the cache dir).
8534    ///
8535    ///Sends a `POST` request to `/core/du`
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    /// - `dir`: Local directory path to report disk usage for. Defaults to the
8542    ///   rclone cache directory when omitted.
8543    pub async fn core_du<'a>(
8544        &'a self,
8545        async_: Option<bool>,
8546        group: Option<&'a str>,
8547        dir: Option<&'a str>,
8548    ) -> Result<ResponseValue<types::CoreDuResponse>, Error<types::RcError>> {
8549        let url = format!("{}/core/du", self.baseurl,);
8550        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8551        header_map.append(
8552            ::reqwest::header::HeaderName::from_static("api-version"),
8553            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8554        );
8555        #[allow(unused_mut)]
8556        let mut request = self
8557            .client
8558            .post(url)
8559            .header(
8560                ::reqwest::header::ACCEPT,
8561                ::reqwest::header::HeaderValue::from_static("application/json"),
8562            )
8563            .query(&progenitor_client::QueryParam::new("_async", &async_))
8564            .query(&progenitor_client::QueryParam::new("_group", &group))
8565            .query(&progenitor_client::QueryParam::new("dir", &dir))
8566            .headers(header_map)
8567            .build()?;
8568        let info = OperationInfo {
8569            operation_id: "core_du",
8570        };
8571        self.pre(&mut request, &info).await?;
8572        let result = self.exec(request, &info).await;
8573        self.post(&result, &info).await?;
8574        let response = result?;
8575        match response.status().as_u16() {
8576            200u16 => ResponseValue::from_response(response).await,
8577            400u16..=499u16 => Err(Error::ErrorResponse(
8578                ResponseValue::from_response(response).await?,
8579            )),
8580            500u16..=599u16 => Err(Error::ErrorResponse(
8581                ResponseValue::from_response(response).await?,
8582            )),
8583            _ => Err(Error::UnexpectedResponse(response)),
8584        }
8585    }
8586
8587    ///Force garbage collection
8588    ///
8589    ///Triggers Go's garbage collector to release unused memory.
8590    ///
8591    ///Sends a `POST` request to `/core/gc`
8592    ///
8593    ///Arguments:
8594    /// - `async_`: Run the command asynchronously. Returns a job id
8595    ///   immediately.
8596    /// - `group`: Assign the request to a custom stats group.
8597    pub async fn core_gc<'a>(
8598        &'a self,
8599        async_: Option<bool>,
8600        group: Option<&'a str>,
8601    ) -> Result<
8602        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8603        Error<types::RcError>,
8604    > {
8605        let url = format!("{}/core/gc", self.baseurl,);
8606        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8607        header_map.append(
8608            ::reqwest::header::HeaderName::from_static("api-version"),
8609            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8610        );
8611        #[allow(unused_mut)]
8612        let mut request = self
8613            .client
8614            .post(url)
8615            .header(
8616                ::reqwest::header::ACCEPT,
8617                ::reqwest::header::HeaderValue::from_static("application/json"),
8618            )
8619            .query(&progenitor_client::QueryParam::new("_async", &async_))
8620            .query(&progenitor_client::QueryParam::new("_group", &group))
8621            .headers(header_map)
8622            .build()?;
8623        let info = OperationInfo {
8624            operation_id: "core_gc",
8625        };
8626        self.pre(&mut request, &info).await?;
8627        let result = self.exec(request, &info).await;
8628        self.post(&result, &info).await?;
8629        let response = result?;
8630        match response.status().as_u16() {
8631            200u16 => ResponseValue::from_response(response).await,
8632            400u16..=499u16 => Err(Error::ErrorResponse(
8633                ResponseValue::from_response(response).await?,
8634            )),
8635            500u16..=599u16 => Err(Error::ErrorResponse(
8636                ResponseValue::from_response(response).await?,
8637            )),
8638            _ => Err(Error::UnexpectedResponse(response)),
8639        }
8640    }
8641
8642    ///List stats groups
8643    ///
8644    ///Lists stats groups currently tracked by rclone.
8645    ///
8646    ///Sends a `POST` request to `/core/group-list`
8647    ///
8648    ///Arguments:
8649    /// - `async_`: Run the command asynchronously. Returns a job id
8650    ///   immediately.
8651    /// - `group`: Assign the request to a custom stats group.
8652    pub async fn core_group_list<'a>(
8653        &'a self,
8654        async_: Option<bool>,
8655        group: Option<&'a str>,
8656    ) -> Result<ResponseValue<types::CoreGroupListResponse>, Error<types::RcError>> {
8657        let url = format!("{}/core/group-list", self.baseurl,);
8658        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8659        header_map.append(
8660            ::reqwest::header::HeaderName::from_static("api-version"),
8661            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8662        );
8663        #[allow(unused_mut)]
8664        let mut request = self
8665            .client
8666            .post(url)
8667            .header(
8668                ::reqwest::header::ACCEPT,
8669                ::reqwest::header::HeaderValue::from_static("application/json"),
8670            )
8671            .query(&progenitor_client::QueryParam::new("_async", &async_))
8672            .query(&progenitor_client::QueryParam::new("_group", &group))
8673            .headers(header_map)
8674            .build()?;
8675        let info = OperationInfo {
8676            operation_id: "core_group_list",
8677        };
8678        self.pre(&mut request, &info).await?;
8679        let result = self.exec(request, &info).await;
8680        self.post(&result, &info).await?;
8681        let response = result?;
8682        match response.status().as_u16() {
8683            200u16 => ResponseValue::from_response(response).await,
8684            400u16..=499u16 => Err(Error::ErrorResponse(
8685                ResponseValue::from_response(response).await?,
8686            )),
8687            500u16..=599u16 => Err(Error::ErrorResponse(
8688                ResponseValue::from_response(response).await?,
8689            )),
8690            _ => Err(Error::UnexpectedResponse(response)),
8691        }
8692    }
8693
8694    ///Fetch runtime memory stats
8695    ///
8696    ///Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
8697    ///
8698    ///Sends a `POST` request to `/core/memstats`
8699    ///
8700    ///Arguments:
8701    /// - `async_`: Run the command asynchronously. Returns a job id
8702    ///   immediately.
8703    /// - `group`: Assign the request to a custom stats group.
8704    pub async fn core_memstats<'a>(
8705        &'a self,
8706        async_: Option<bool>,
8707        group: Option<&'a str>,
8708    ) -> Result<
8709        ResponseValue<::std::collections::HashMap<::std::string::String, f64>>,
8710        Error<types::RcError>,
8711    > {
8712        let url = format!("{}/core/memstats", self.baseurl,);
8713        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8714        header_map.append(
8715            ::reqwest::header::HeaderName::from_static("api-version"),
8716            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8717        );
8718        #[allow(unused_mut)]
8719        let mut request = self
8720            .client
8721            .post(url)
8722            .header(
8723                ::reqwest::header::ACCEPT,
8724                ::reqwest::header::HeaderValue::from_static("application/json"),
8725            )
8726            .query(&progenitor_client::QueryParam::new("_async", &async_))
8727            .query(&progenitor_client::QueryParam::new("_group", &group))
8728            .headers(header_map)
8729            .build()?;
8730        let info = OperationInfo {
8731            operation_id: "core_memstats",
8732        };
8733        self.pre(&mut request, &info).await?;
8734        let result = self.exec(request, &info).await;
8735        self.post(&result, &info).await?;
8736        let response = result?;
8737        match response.status().as_u16() {
8738            200u16 => ResponseValue::from_response(response).await,
8739            400u16..=499u16 => Err(Error::ErrorResponse(
8740                ResponseValue::from_response(response).await?,
8741            )),
8742            500u16..=599u16 => Err(Error::ErrorResponse(
8743                ResponseValue::from_response(response).await?,
8744            )),
8745            _ => Err(Error::UnexpectedResponse(response)),
8746        }
8747    }
8748
8749    ///Obscure a clear string
8750    ///
8751    ///Obscures a plain-text secret for inclusion in `rclone.conf`.
8752    ///
8753    ///Sends a `POST` request to `/core/obscure`
8754    ///
8755    ///Arguments:
8756    /// - `async_`: Run the command asynchronously. Returns a job id
8757    ///   immediately.
8758    /// - `group`: Assign the request to a custom stats group.
8759    /// - `clear`: Plain-text string to obscure for storage in the config file.
8760    pub async fn core_obscure<'a>(
8761        &'a self,
8762        async_: Option<bool>,
8763        group: Option<&'a str>,
8764        clear: &'a str,
8765    ) -> Result<ResponseValue<types::CoreObscureResponse>, Error<types::RcError>> {
8766        let url = format!("{}/core/obscure", self.baseurl,);
8767        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8768        header_map.append(
8769            ::reqwest::header::HeaderName::from_static("api-version"),
8770            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8771        );
8772        #[allow(unused_mut)]
8773        let mut request = self
8774            .client
8775            .post(url)
8776            .header(
8777                ::reqwest::header::ACCEPT,
8778                ::reqwest::header::HeaderValue::from_static("application/json"),
8779            )
8780            .query(&progenitor_client::QueryParam::new("_async", &async_))
8781            .query(&progenitor_client::QueryParam::new("_group", &group))
8782            .query(&progenitor_client::QueryParam::new("clear", &clear))
8783            .headers(header_map)
8784            .build()?;
8785        let info = OperationInfo {
8786            operation_id: "core_obscure",
8787        };
8788        self.pre(&mut request, &info).await?;
8789        let result = self.exec(request, &info).await;
8790        self.post(&result, &info).await?;
8791        let response = result?;
8792        match response.status().as_u16() {
8793            200u16 => ResponseValue::from_response(response).await,
8794            400u16..=499u16 => Err(Error::ErrorResponse(
8795                ResponseValue::from_response(response).await?,
8796            )),
8797            500u16..=599u16 => Err(Error::ErrorResponse(
8798                ResponseValue::from_response(response).await?,
8799            )),
8800            _ => Err(Error::UnexpectedResponse(response)),
8801        }
8802    }
8803
8804    ///Return rclone PID
8805    ///
8806    ///Returns the process ID of the running rclone instance.
8807    ///
8808    ///Sends a `POST` request to `/core/pid`
8809    ///
8810    ///Arguments:
8811    /// - `async_`: Run the command asynchronously. Returns a job id
8812    ///   immediately.
8813    /// - `group`: Assign the request to a custom stats group.
8814    pub async fn core_pid<'a>(
8815        &'a self,
8816        async_: Option<bool>,
8817        group: Option<&'a str>,
8818    ) -> Result<ResponseValue<types::CorePidResponse>, Error<types::RcError>> {
8819        let url = format!("{}/core/pid", self.baseurl,);
8820        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8821        header_map.append(
8822            ::reqwest::header::HeaderName::from_static("api-version"),
8823            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8824        );
8825        #[allow(unused_mut)]
8826        let mut request = self
8827            .client
8828            .post(url)
8829            .header(
8830                ::reqwest::header::ACCEPT,
8831                ::reqwest::header::HeaderValue::from_static("application/json"),
8832            )
8833            .query(&progenitor_client::QueryParam::new("_async", &async_))
8834            .query(&progenitor_client::QueryParam::new("_group", &group))
8835            .headers(header_map)
8836            .build()?;
8837        let info = OperationInfo {
8838            operation_id: "core_pid",
8839        };
8840        self.pre(&mut request, &info).await?;
8841        let result = self.exec(request, &info).await;
8842        self.post(&result, &info).await?;
8843        let response = result?;
8844        match response.status().as_u16() {
8845            200u16 => ResponseValue::from_response(response).await,
8846            400u16..=499u16 => Err(Error::ErrorResponse(
8847                ResponseValue::from_response(response).await?,
8848            )),
8849            500u16..=599u16 => Err(Error::ErrorResponse(
8850                ResponseValue::from_response(response).await?,
8851            )),
8852            _ => Err(Error::UnexpectedResponse(response)),
8853        }
8854    }
8855
8856    ///Terminate rclone
8857    ///
8858    ///Stops the rclone process, optionally supplying an exit code.
8859    ///
8860    ///Sends a `POST` request to `/core/quit`
8861    ///
8862    ///Arguments:
8863    /// - `async_`: Run the command asynchronously. Returns a job id
8864    ///   immediately.
8865    /// - `group`: Assign the request to a custom stats group.
8866    /// - `exit_code`: Optional exit code to use when terminating the rclone
8867    ///   process.
8868    pub async fn core_quit<'a>(
8869        &'a self,
8870        async_: Option<bool>,
8871        group: Option<&'a str>,
8872        exit_code: Option<i64>,
8873    ) -> Result<
8874        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8875        Error<types::RcError>,
8876    > {
8877        let url = format!("{}/core/quit", self.baseurl,);
8878        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8879        header_map.append(
8880            ::reqwest::header::HeaderName::from_static("api-version"),
8881            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8882        );
8883        #[allow(unused_mut)]
8884        let mut request = self
8885            .client
8886            .post(url)
8887            .header(
8888                ::reqwest::header::ACCEPT,
8889                ::reqwest::header::HeaderValue::from_static("application/json"),
8890            )
8891            .query(&progenitor_client::QueryParam::new("_async", &async_))
8892            .query(&progenitor_client::QueryParam::new("_group", &group))
8893            .query(&progenitor_client::QueryParam::new("exitCode", &exit_code))
8894            .headers(header_map)
8895            .build()?;
8896        let info = OperationInfo {
8897            operation_id: "core_quit",
8898        };
8899        self.pre(&mut request, &info).await?;
8900        let result = self.exec(request, &info).await;
8901        self.post(&result, &info).await?;
8902        let response = result?;
8903        match response.status().as_u16() {
8904            200u16 => ResponseValue::from_response(response).await,
8905            400u16..=499u16 => Err(Error::ErrorResponse(
8906                ResponseValue::from_response(response).await?,
8907            )),
8908            500u16..=599u16 => Err(Error::ErrorResponse(
8909                ResponseValue::from_response(response).await?,
8910            )),
8911            _ => Err(Error::UnexpectedResponse(response)),
8912        }
8913    }
8914
8915    ///Delete stats group
8916    ///
8917    ///Deletes the counters associated with a specific stats group.
8918    ///
8919    ///Sends a `POST` request to `/core/stats-delete`
8920    ///
8921    ///Arguments:
8922    /// - `async_`: Run the command asynchronously. Returns a job id
8923    ///   immediately.
8924    /// - `group`: Assign the request to a custom stats group.
8925    /// - `group`: Stats group identifier to remove.
8926    pub async fn core_stats_delete<'a>(
8927        &'a self,
8928        async_: Option<bool>,
8929        _group: Option<&'a str>,
8930        group: &'a str
8931    ) -> Result<
8932        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8933        Error<types::RcError>,
8934    > {
8935        let url = format!("{}/core/stats-delete", self.baseurl,);
8936        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8937        header_map.append(
8938            ::reqwest::header::HeaderName::from_static("api-version"),
8939            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8940        );
8941        #[allow(unused_mut)]
8942        let mut request = self
8943            .client
8944            .post(url)
8945            .header(
8946                ::reqwest::header::ACCEPT,
8947                ::reqwest::header::HeaderValue::from_static("application/json"),
8948            )
8949            .query(&progenitor_client::QueryParam::new("_async", &async_))
8950            .query(&progenitor_client::QueryParam::new("_group", &group))
8951            .query(&progenitor_client::QueryParam::new("group", &group))
8952            .headers(header_map)
8953            .build()?;
8954        let info = OperationInfo {
8955            operation_id: "core_stats_delete",
8956        };
8957        self.pre(&mut request, &info).await?;
8958        let result = self.exec(request, &info).await;
8959        self.post(&result, &info).await?;
8960        let response = result?;
8961        match response.status().as_u16() {
8962            200u16 => ResponseValue::from_response(response).await,
8963            400u16..=499u16 => Err(Error::ErrorResponse(
8964                ResponseValue::from_response(response).await?,
8965            )),
8966            500u16..=599u16 => Err(Error::ErrorResponse(
8967                ResponseValue::from_response(response).await?,
8968            )),
8969            _ => Err(Error::UnexpectedResponse(response)),
8970        }
8971    }
8972
8973    ///Reset stats counters
8974    ///
8975    ///Clears counters, errors, and finished transfers for the provided stats
8976    /// group or all groups.
8977    ///
8978    ///Sends a `POST` request to `/core/stats-reset`
8979    ///
8980    ///Arguments:
8981    /// - `async_`: Run the command asynchronously. Returns a job id
8982    ///   immediately.
8983    /// - `group`: Assign the request to a custom stats group.
8984    /// - `group`: Stats group identifier whose counters should be reset. Leave
8985    ///   unset to reset all groups.
8986    pub async fn core_stats_reset<'a>(
8987        &'a self,
8988        async_: Option<bool>,
8989        _group: Option<&'a str>,
8990        group: Option<&'a str>
8991    ) -> Result<
8992        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
8993        Error<types::RcError>,
8994    > {
8995        let url = format!("{}/core/stats-reset", self.baseurl,);
8996        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8997        header_map.append(
8998            ::reqwest::header::HeaderName::from_static("api-version"),
8999            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9000        );
9001        #[allow(unused_mut)]
9002        let mut request = self
9003            .client
9004            .post(url)
9005            .header(
9006                ::reqwest::header::ACCEPT,
9007                ::reqwest::header::HeaderValue::from_static("application/json"),
9008            )
9009            .query(&progenitor_client::QueryParam::new("_async", &async_))
9010            .query(&progenitor_client::QueryParam::new("_group", &group))
9011            .query(&progenitor_client::QueryParam::new("group", &group))
9012            .headers(header_map)
9013            .build()?;
9014        let info = OperationInfo {
9015            operation_id: "core_stats_reset",
9016        };
9017        self.pre(&mut request, &info).await?;
9018        let result = self.exec(request, &info).await;
9019        self.post(&result, &info).await?;
9020        let response = result?;
9021        match response.status().as_u16() {
9022            200u16 => ResponseValue::from_response(response).await,
9023            400u16..=499u16 => Err(Error::ErrorResponse(
9024                ResponseValue::from_response(response).await?,
9025            )),
9026            500u16..=599u16 => Err(Error::ErrorResponse(
9027                ResponseValue::from_response(response).await?,
9028            )),
9029            _ => Err(Error::UnexpectedResponse(response)),
9030        }
9031    }
9032
9033    ///List completed transfers
9034    ///
9035    ///Returns up to 100 recently completed transfers for the requested stats
9036    /// group.
9037    ///
9038    ///Sends a `POST` request to `/core/transferred`
9039    ///
9040    ///Arguments:
9041    /// - `async_`: Run the command asynchronously. Returns a job id
9042    ///   immediately.
9043    /// - `group`: Assign the request to a custom stats group.
9044    /// - `group`: Stats group identifier to filter the completed transfer list.
9045    ///   Leave unset for all groups.
9046    pub async fn core_transferred<'a>(
9047        &'a self,
9048        async_: Option<bool>,
9049        _group: Option<&'a str>,
9050        group: Option<&'a str>
9051    ) -> Result<ResponseValue<types::CoreTransferredResponse>, Error<types::RcError>> {
9052        let url = format!("{}/core/transferred", self.baseurl,);
9053        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9054        header_map.append(
9055            ::reqwest::header::HeaderName::from_static("api-version"),
9056            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9057        );
9058        #[allow(unused_mut)]
9059        let mut request = self
9060            .client
9061            .post(url)
9062            .header(
9063                ::reqwest::header::ACCEPT,
9064                ::reqwest::header::HeaderValue::from_static("application/json"),
9065            )
9066            .query(&progenitor_client::QueryParam::new("_async", &async_))
9067            .query(&progenitor_client::QueryParam::new("_group", &group))
9068            .query(&progenitor_client::QueryParam::new("group", &group))
9069            .headers(header_map)
9070            .build()?;
9071        let info = OperationInfo {
9072            operation_id: "core_transferred",
9073        };
9074        self.pre(&mut request, &info).await?;
9075        let result = self.exec(request, &info).await;
9076        self.post(&result, &info).await?;
9077        let response = result?;
9078        match response.status().as_u16() {
9079            200u16 => ResponseValue::from_response(response).await,
9080            400u16..=499u16 => Err(Error::ErrorResponse(
9081                ResponseValue::from_response(response).await?,
9082            )),
9083            500u16..=599u16 => Err(Error::ErrorResponse(
9084                ResponseValue::from_response(response).await?,
9085            )),
9086            _ => Err(Error::UnexpectedResponse(response)),
9087        }
9088    }
9089
9090    ///Sends a `POST` request to `/debug/set-block-profile-rate`
9091    ///
9092    ///Arguments:
9093    /// - `async_`: Run the command asynchronously. Returns a job id
9094    ///   immediately.
9095    /// - `group`: Assign the request to a custom stats group.
9096    /// - `rate`: Sampling interval in nanoseconds for blocking profile
9097    ///   collection; use 1 to capture all events.
9098    pub async fn debug_set_block_profile_rate<'a>(
9099        &'a self,
9100        async_: Option<bool>,
9101        group: Option<&'a str>,
9102        rate: i64,
9103    ) -> Result<
9104        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9105        Error<types::RcError>,
9106    > {
9107        let url = format!("{}/debug/set-block-profile-rate", self.baseurl,);
9108        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9109        header_map.append(
9110            ::reqwest::header::HeaderName::from_static("api-version"),
9111            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9112        );
9113        #[allow(unused_mut)]
9114        let mut request = self
9115            .client
9116            .post(url)
9117            .header(
9118                ::reqwest::header::ACCEPT,
9119                ::reqwest::header::HeaderValue::from_static("application/json"),
9120            )
9121            .query(&progenitor_client::QueryParam::new("_async", &async_))
9122            .query(&progenitor_client::QueryParam::new("_group", &group))
9123            .query(&progenitor_client::QueryParam::new("rate", &rate))
9124            .headers(header_map)
9125            .build()?;
9126        let info = OperationInfo {
9127            operation_id: "debug_set_block_profile_rate",
9128        };
9129        self.pre(&mut request, &info).await?;
9130        let result = self.exec(request, &info).await;
9131        self.post(&result, &info).await?;
9132        let response = result?;
9133        match response.status().as_u16() {
9134            200u16 => ResponseValue::from_response(response).await,
9135            400u16..=499u16 => Err(Error::ErrorResponse(
9136                ResponseValue::from_response(response).await?,
9137            )),
9138            500u16..=599u16 => Err(Error::ErrorResponse(
9139                ResponseValue::from_response(response).await?,
9140            )),
9141            _ => Err(Error::UnexpectedResponse(response)),
9142        }
9143    }
9144
9145    ///Sends a `POST` request to `/debug/set-gc-percent`
9146    ///
9147    ///Arguments:
9148    /// - `async_`: Run the command asynchronously. Returns a job id
9149    ///   immediately.
9150    /// - `group`: Assign the request to a custom stats group.
9151    /// - `gc_percent`: Target percentage of newly allocated data to trigger
9152    ///   garbage collection.
9153    pub async fn debug_set_gc_percent<'a>(
9154        &'a self,
9155        async_: Option<bool>,
9156        group: Option<&'a str>,
9157        gc_percent: i64,
9158    ) -> Result<ResponseValue<types::DebugSetGcPercentResponse>, Error<types::RcError>> {
9159        let url = format!("{}/debug/set-gc-percent", self.baseurl,);
9160        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9161        header_map.append(
9162            ::reqwest::header::HeaderName::from_static("api-version"),
9163            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9164        );
9165        #[allow(unused_mut)]
9166        let mut request = self
9167            .client
9168            .post(url)
9169            .header(
9170                ::reqwest::header::ACCEPT,
9171                ::reqwest::header::HeaderValue::from_static("application/json"),
9172            )
9173            .query(&progenitor_client::QueryParam::new("_async", &async_))
9174            .query(&progenitor_client::QueryParam::new("_group", &group))
9175            .query(&progenitor_client::QueryParam::new(
9176                "gc-percent",
9177                &gc_percent,
9178            ))
9179            .headers(header_map)
9180            .build()?;
9181        let info = OperationInfo {
9182            operation_id: "debug_set_gc_percent",
9183        };
9184        self.pre(&mut request, &info).await?;
9185        let result = self.exec(request, &info).await;
9186        self.post(&result, &info).await?;
9187        let response = result?;
9188        match response.status().as_u16() {
9189            200u16 => ResponseValue::from_response(response).await,
9190            400u16..=499u16 => Err(Error::ErrorResponse(
9191                ResponseValue::from_response(response).await?,
9192            )),
9193            500u16..=599u16 => Err(Error::ErrorResponse(
9194                ResponseValue::from_response(response).await?,
9195            )),
9196            _ => Err(Error::UnexpectedResponse(response)),
9197        }
9198    }
9199
9200    ///Sends a `POST` request to `/debug/set-mutex-profile-fraction`
9201    ///
9202    ///Arguments:
9203    /// - `async_`: Run the command asynchronously. Returns a job id
9204    ///   immediately.
9205    /// - `group`: Assign the request to a custom stats group.
9206    /// - `rate`: Sampling fraction for mutex contention profiling; set to 0 to
9207    ///   disable.
9208    pub async fn debug_set_mutex_profile_fraction<'a>(
9209        &'a self,
9210        async_: Option<bool>,
9211        group: Option<&'a str>,
9212        rate: i64,
9213    ) -> Result<ResponseValue<types::DebugSetMutexProfileFractionResponse>, Error<types::RcError>>
9214    {
9215        let url = format!("{}/debug/set-mutex-profile-fraction", self.baseurl,);
9216        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9217        header_map.append(
9218            ::reqwest::header::HeaderName::from_static("api-version"),
9219            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9220        );
9221        #[allow(unused_mut)]
9222        let mut request = self
9223            .client
9224            .post(url)
9225            .header(
9226                ::reqwest::header::ACCEPT,
9227                ::reqwest::header::HeaderValue::from_static("application/json"),
9228            )
9229            .query(&progenitor_client::QueryParam::new("_async", &async_))
9230            .query(&progenitor_client::QueryParam::new("_group", &group))
9231            .query(&progenitor_client::QueryParam::new("rate", &rate))
9232            .headers(header_map)
9233            .build()?;
9234        let info = OperationInfo {
9235            operation_id: "debug_set_mutex_profile_fraction",
9236        };
9237        self.pre(&mut request, &info).await?;
9238        let result = self.exec(request, &info).await;
9239        self.post(&result, &info).await?;
9240        let response = result?;
9241        match response.status().as_u16() {
9242            200u16 => ResponseValue::from_response(response).await,
9243            400u16..=499u16 => Err(Error::ErrorResponse(
9244                ResponseValue::from_response(response).await?,
9245            )),
9246            500u16..=599u16 => Err(Error::ErrorResponse(
9247                ResponseValue::from_response(response).await?,
9248            )),
9249            _ => Err(Error::UnexpectedResponse(response)),
9250        }
9251    }
9252
9253    ///Sends a `POST` request to `/debug/set-soft-memory-limit`
9254    ///
9255    ///Arguments:
9256    /// - `async_`: Run the command asynchronously. Returns a job id
9257    ///   immediately.
9258    /// - `group`: Assign the request to a custom stats group.
9259    /// - `mem_limit`: Soft memory limit for the Go runtime in bytes.
9260    pub async fn debug_set_soft_memory_limit<'a>(
9261        &'a self,
9262        async_: Option<bool>,
9263        group: Option<&'a str>,
9264        mem_limit: i64,
9265    ) -> Result<ResponseValue<types::DebugSetSoftMemoryLimitResponse>, Error<types::RcError>> {
9266        let url = format!("{}/debug/set-soft-memory-limit", self.baseurl,);
9267        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9268        header_map.append(
9269            ::reqwest::header::HeaderName::from_static("api-version"),
9270            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9271        );
9272        #[allow(unused_mut)]
9273        let mut request = self
9274            .client
9275            .post(url)
9276            .header(
9277                ::reqwest::header::ACCEPT,
9278                ::reqwest::header::HeaderValue::from_static("application/json"),
9279            )
9280            .query(&progenitor_client::QueryParam::new("_async", &async_))
9281            .query(&progenitor_client::QueryParam::new("_group", &group))
9282            .query(&progenitor_client::QueryParam::new("mem-limit", &mem_limit))
9283            .headers(header_map)
9284            .build()?;
9285        let info = OperationInfo {
9286            operation_id: "debug_set_soft_memory_limit",
9287        };
9288        self.pre(&mut request, &info).await?;
9289        let result = self.exec(request, &info).await;
9290        self.post(&result, &info).await?;
9291        let response = result?;
9292        match response.status().as_u16() {
9293            200u16 => ResponseValue::from_response(response).await,
9294            400u16..=499u16 => Err(Error::ErrorResponse(
9295                ResponseValue::from_response(response).await?,
9296            )),
9297            500u16..=599u16 => Err(Error::ErrorResponse(
9298                ResponseValue::from_response(response).await?,
9299            )),
9300            _ => Err(Error::UnexpectedResponse(response)),
9301        }
9302    }
9303
9304    ///Sends a `POST` request to `/fscache/clear`
9305    ///
9306    ///Arguments:
9307    /// - `async_`: Run the command asynchronously. Returns a job id
9308    ///   immediately.
9309    /// - `group`: Assign the request to a custom stats group.
9310    pub async fn fscache_clear<'a>(
9311        &'a self,
9312        async_: Option<bool>,
9313        group: Option<&'a str>,
9314    ) -> Result<
9315        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9316        Error<types::RcError>,
9317    > {
9318        let url = format!("{}/fscache/clear", self.baseurl,);
9319        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9320        header_map.append(
9321            ::reqwest::header::HeaderName::from_static("api-version"),
9322            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9323        );
9324        #[allow(unused_mut)]
9325        let mut request = self
9326            .client
9327            .post(url)
9328            .header(
9329                ::reqwest::header::ACCEPT,
9330                ::reqwest::header::HeaderValue::from_static("application/json"),
9331            )
9332            .query(&progenitor_client::QueryParam::new("_async", &async_))
9333            .query(&progenitor_client::QueryParam::new("_group", &group))
9334            .headers(header_map)
9335            .build()?;
9336        let info = OperationInfo {
9337            operation_id: "fscache_clear",
9338        };
9339        self.pre(&mut request, &info).await?;
9340        let result = self.exec(request, &info).await;
9341        self.post(&result, &info).await?;
9342        let response = result?;
9343        match response.status().as_u16() {
9344            200u16 => ResponseValue::from_response(response).await,
9345            400u16..=499u16 => Err(Error::ErrorResponse(
9346                ResponseValue::from_response(response).await?,
9347            )),
9348            500u16..=599u16 => Err(Error::ErrorResponse(
9349                ResponseValue::from_response(response).await?,
9350            )),
9351            _ => Err(Error::UnexpectedResponse(response)),
9352        }
9353    }
9354
9355    ///Sends a `POST` request to `/fscache/entries`
9356    ///
9357    ///Arguments:
9358    /// - `async_`: Run the command asynchronously. Returns a job id
9359    ///   immediately.
9360    /// - `group`: Assign the request to a custom stats group.
9361    pub async fn fscache_entries<'a>(
9362        &'a self,
9363        async_: Option<bool>,
9364        group: Option<&'a str>,
9365    ) -> Result<ResponseValue<types::FscacheEntriesResponse>, Error<types::RcError>> {
9366        let url = format!("{}/fscache/entries", self.baseurl,);
9367        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9368        header_map.append(
9369            ::reqwest::header::HeaderName::from_static("api-version"),
9370            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9371        );
9372        #[allow(unused_mut)]
9373        let mut request = self
9374            .client
9375            .post(url)
9376            .header(
9377                ::reqwest::header::ACCEPT,
9378                ::reqwest::header::HeaderValue::from_static("application/json"),
9379            )
9380            .query(&progenitor_client::QueryParam::new("_async", &async_))
9381            .query(&progenitor_client::QueryParam::new("_group", &group))
9382            .headers(header_map)
9383            .build()?;
9384        let info = OperationInfo {
9385            operation_id: "fscache_entries",
9386        };
9387        self.pre(&mut request, &info).await?;
9388        let result = self.exec(request, &info).await;
9389        self.post(&result, &info).await?;
9390        let response = result?;
9391        match response.status().as_u16() {
9392            200u16 => ResponseValue::from_response(response).await,
9393            400u16..=499u16 => Err(Error::ErrorResponse(
9394                ResponseValue::from_response(response).await?,
9395            )),
9396            500u16..=599u16 => Err(Error::ErrorResponse(
9397                ResponseValue::from_response(response).await?,
9398            )),
9399            _ => Err(Error::UnexpectedResponse(response)),
9400        }
9401    }
9402
9403    ///Sends a `POST` request to `/mount/listmounts`
9404    ///
9405    ///Arguments:
9406    /// - `async_`: Run the command asynchronously. Returns a job id
9407    ///   immediately.
9408    /// - `group`: Assign the request to a custom stats group.
9409    pub async fn mount_listmounts<'a>(
9410        &'a self,
9411        async_: Option<bool>,
9412        group: Option<&'a str>,
9413    ) -> Result<ResponseValue<types::MountListmountsResponse>, Error<types::RcError>> {
9414        let url = format!("{}/mount/listmounts", self.baseurl,);
9415        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9416        header_map.append(
9417            ::reqwest::header::HeaderName::from_static("api-version"),
9418            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9419        );
9420        #[allow(unused_mut)]
9421        let mut request = self
9422            .client
9423            .post(url)
9424            .header(
9425                ::reqwest::header::ACCEPT,
9426                ::reqwest::header::HeaderValue::from_static("application/json"),
9427            )
9428            .query(&progenitor_client::QueryParam::new("_async", &async_))
9429            .query(&progenitor_client::QueryParam::new("_group", &group))
9430            .headers(header_map)
9431            .build()?;
9432        let info = OperationInfo {
9433            operation_id: "mount_listmounts",
9434        };
9435        self.pre(&mut request, &info).await?;
9436        let result = self.exec(request, &info).await;
9437        self.post(&result, &info).await?;
9438        let response = result?;
9439        match response.status().as_u16() {
9440            200u16 => ResponseValue::from_response(response).await,
9441            400u16..=499u16 => Err(Error::ErrorResponse(
9442                ResponseValue::from_response(response).await?,
9443            )),
9444            500u16..=599u16 => Err(Error::ErrorResponse(
9445                ResponseValue::from_response(response).await?,
9446            )),
9447            _ => Err(Error::UnexpectedResponse(response)),
9448        }
9449    }
9450
9451    ///Sends a `POST` request to `/mount/mount`
9452    ///
9453    ///Arguments:
9454    /// - `async_`: Run the command asynchronously. Returns a job id
9455    ///   immediately.
9456    /// - `config`: JSON encoded config overrides applied for this call only.
9457    /// - `filter`: JSON encoded filter overrides applied for this call only.
9458    /// - `group`: Assign the request to a custom stats group.
9459    /// - `fs`: Remote path to mount, such as `drive:` or `remote:subdir`.
9460    /// - `mount_opt`: Mount options encoded as JSON, matching flags accepted by
9461    ///   `rclone mount`.
9462    /// - `mount_point`: Absolute local path where the remote should be mounted.
9463    /// - `mount_type`: Optional mount implementation to use (`mount`, `cmount`,
9464    ///   or `mount2`).
9465    /// - `vfs_opt`: VFS options encoded as JSON, matching flags accepted by
9466    ///   `rclone mount`.
9467    pub async fn mount_mount<'a>(
9468        &'a self,
9469        async_: Option<bool>,
9470        config: Option<&'a str>,
9471        filter: Option<&'a str>,
9472        group: Option<&'a str>,
9473        fs: &'a str,
9474        mount_opt: Option<&'a str>,
9475        mount_point: &'a str,
9476        mount_type: Option<&'a str>,
9477        vfs_opt: Option<&'a str>,
9478    ) -> Result<
9479        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9480        Error<types::RcError>,
9481    > {
9482        let url = format!("{}/mount/mount", self.baseurl,);
9483        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9484        header_map.append(
9485            ::reqwest::header::HeaderName::from_static("api-version"),
9486            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9487        );
9488        #[allow(unused_mut)]
9489        let mut request = self
9490            .client
9491            .post(url)
9492            .header(
9493                ::reqwest::header::ACCEPT,
9494                ::reqwest::header::HeaderValue::from_static("application/json"),
9495            )
9496            .query(&progenitor_client::QueryParam::new("_async", &async_))
9497            .query(&progenitor_client::QueryParam::new("_config", &config))
9498            .query(&progenitor_client::QueryParam::new("_filter", &filter))
9499            .query(&progenitor_client::QueryParam::new("_group", &group))
9500            .query(&progenitor_client::QueryParam::new("fs", &fs))
9501            .query(&progenitor_client::QueryParam::new("mountOpt", &mount_opt))
9502            .query(&progenitor_client::QueryParam::new(
9503                "mountPoint",
9504                &mount_point,
9505            ))
9506            .query(&progenitor_client::QueryParam::new(
9507                "mountType",
9508                &mount_type,
9509            ))
9510            .query(&progenitor_client::QueryParam::new("vfsOpt", &vfs_opt))
9511            .headers(header_map)
9512            .build()?;
9513        let info = OperationInfo {
9514            operation_id: "mount_mount",
9515        };
9516        self.pre(&mut request, &info).await?;
9517        let result = self.exec(request, &info).await;
9518        self.post(&result, &info).await?;
9519        let response = result?;
9520        match response.status().as_u16() {
9521            200u16 => ResponseValue::from_response(response).await,
9522            400u16..=499u16 => Err(Error::ErrorResponse(
9523                ResponseValue::from_response(response).await?,
9524            )),
9525            500u16..=599u16 => Err(Error::ErrorResponse(
9526                ResponseValue::from_response(response).await?,
9527            )),
9528            _ => Err(Error::UnexpectedResponse(response)),
9529        }
9530    }
9531
9532    ///Sends a `POST` request to `/mount/types`
9533    ///
9534    ///Arguments:
9535    /// - `async_`: Run the command asynchronously. Returns a job id
9536    ///   immediately.
9537    /// - `group`: Assign the request to a custom stats group.
9538    pub async fn mount_types<'a>(
9539        &'a self,
9540        async_: Option<bool>,
9541        group: Option<&'a str>,
9542    ) -> Result<ResponseValue<types::MountTypesResponse>, Error<types::RcError>> {
9543        let url = format!("{}/mount/types", self.baseurl,);
9544        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9545        header_map.append(
9546            ::reqwest::header::HeaderName::from_static("api-version"),
9547            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9548        );
9549        #[allow(unused_mut)]
9550        let mut request = self
9551            .client
9552            .post(url)
9553            .header(
9554                ::reqwest::header::ACCEPT,
9555                ::reqwest::header::HeaderValue::from_static("application/json"),
9556            )
9557            .query(&progenitor_client::QueryParam::new("_async", &async_))
9558            .query(&progenitor_client::QueryParam::new("_group", &group))
9559            .headers(header_map)
9560            .build()?;
9561        let info = OperationInfo {
9562            operation_id: "mount_types",
9563        };
9564        self.pre(&mut request, &info).await?;
9565        let result = self.exec(request, &info).await;
9566        self.post(&result, &info).await?;
9567        let response = result?;
9568        match response.status().as_u16() {
9569            200u16 => ResponseValue::from_response(response).await,
9570            400u16..=499u16 => Err(Error::ErrorResponse(
9571                ResponseValue::from_response(response).await?,
9572            )),
9573            500u16..=599u16 => Err(Error::ErrorResponse(
9574                ResponseValue::from_response(response).await?,
9575            )),
9576            _ => Err(Error::UnexpectedResponse(response)),
9577        }
9578    }
9579
9580    ///Sends a `POST` request to `/mount/unmount`
9581    ///
9582    ///Arguments:
9583    /// - `async_`: Run the command asynchronously. Returns a job id
9584    ///   immediately.
9585    /// - `group`: Assign the request to a custom stats group.
9586    /// - `mount_point`: Local mount point path to unmount.
9587    pub async fn mount_unmount<'a>(
9588        &'a self,
9589        async_: Option<bool>,
9590        group: Option<&'a str>,
9591        mount_point: &'a str,
9592    ) -> Result<
9593        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9594        Error<types::RcError>,
9595    > {
9596        let url = format!("{}/mount/unmount", self.baseurl,);
9597        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9598        header_map.append(
9599            ::reqwest::header::HeaderName::from_static("api-version"),
9600            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9601        );
9602        #[allow(unused_mut)]
9603        let mut request = self
9604            .client
9605            .post(url)
9606            .header(
9607                ::reqwest::header::ACCEPT,
9608                ::reqwest::header::HeaderValue::from_static("application/json"),
9609            )
9610            .query(&progenitor_client::QueryParam::new("_async", &async_))
9611            .query(&progenitor_client::QueryParam::new("_group", &group))
9612            .query(&progenitor_client::QueryParam::new(
9613                "mountPoint",
9614                &mount_point,
9615            ))
9616            .headers(header_map)
9617            .build()?;
9618        let info = OperationInfo {
9619            operation_id: "mount_unmount",
9620        };
9621        self.pre(&mut request, &info).await?;
9622        let result = self.exec(request, &info).await;
9623        self.post(&result, &info).await?;
9624        let response = result?;
9625        match response.status().as_u16() {
9626            200u16 => ResponseValue::from_response(response).await,
9627            400u16..=499u16 => Err(Error::ErrorResponse(
9628                ResponseValue::from_response(response).await?,
9629            )),
9630            500u16..=599u16 => Err(Error::ErrorResponse(
9631                ResponseValue::from_response(response).await?,
9632            )),
9633            _ => Err(Error::UnexpectedResponse(response)),
9634        }
9635    }
9636
9637    ///Sends a `POST` request to `/mount/unmountall`
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    pub async fn mount_unmountall<'a>(
9644        &'a self,
9645        async_: Option<bool>,
9646        group: Option<&'a str>,
9647    ) -> Result<
9648        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9649        Error<types::RcError>,
9650    > {
9651        let url = format!("{}/mount/unmountall", self.baseurl,);
9652        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9653        header_map.append(
9654            ::reqwest::header::HeaderName::from_static("api-version"),
9655            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9656        );
9657        #[allow(unused_mut)]
9658        let mut request = self
9659            .client
9660            .post(url)
9661            .header(
9662                ::reqwest::header::ACCEPT,
9663                ::reqwest::header::HeaderValue::from_static("application/json"),
9664            )
9665            .query(&progenitor_client::QueryParam::new("_async", &async_))
9666            .query(&progenitor_client::QueryParam::new("_group", &group))
9667            .headers(header_map)
9668            .build()?;
9669        let info = OperationInfo {
9670            operation_id: "mount_unmountall",
9671        };
9672        self.pre(&mut request, &info).await?;
9673        let result = self.exec(request, &info).await;
9674        self.post(&result, &info).await?;
9675        let response = result?;
9676        match response.status().as_u16() {
9677            200u16 => ResponseValue::from_response(response).await,
9678            400u16..=499u16 => Err(Error::ErrorResponse(
9679                ResponseValue::from_response(response).await?,
9680            )),
9681            500u16..=599u16 => Err(Error::ErrorResponse(
9682                ResponseValue::from_response(response).await?,
9683            )),
9684            _ => Err(Error::UnexpectedResponse(response)),
9685        }
9686    }
9687
9688    ///Echo parameters (auth required)
9689    ///
9690    ///Same as `rc/noop`, but requires authentication to validate access
9691    /// control.
9692    ///
9693    ///Sends a `POST` request to `/rc/noopauth`
9694    ///
9695    ///Arguments:
9696    /// - `async_`: Run the command asynchronously. Returns a job id
9697    ///   immediately.
9698    /// - `params`: Additional arbitrary parameters allowed.
9699    pub async fn rc_noop_auth<'a>(
9700        &'a self,
9701        async_: Option<bool>,
9702        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9703    ) -> Result<
9704        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9705        Error<types::RcError>,
9706    > {
9707        let url = format!("{}/rc/noopauth", self.baseurl,);
9708        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9709        header_map.append(
9710            ::reqwest::header::HeaderName::from_static("api-version"),
9711            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9712        );
9713        #[allow(unused_mut)]
9714        let mut request = self
9715            .client
9716            .post(url)
9717            .header(
9718                ::reqwest::header::ACCEPT,
9719                ::reqwest::header::HeaderValue::from_static("application/json"),
9720            )
9721            .query(&progenitor_client::QueryParam::new("_async", &async_))
9722            .query(&progenitor_client::QueryParam::new("params", &params))
9723            .headers(header_map)
9724            .build()?;
9725        let info = OperationInfo {
9726            operation_id: "rc_noop_auth",
9727        };
9728        self.pre(&mut request, &info).await?;
9729        let result = self.exec(request, &info).await;
9730        self.post(&result, &info).await?;
9731        let response = result?;
9732        match response.status().as_u16() {
9733            200u16 => ResponseValue::from_response(response).await,
9734            400u16..=499u16 => Err(Error::ErrorResponse(
9735                ResponseValue::from_response(response).await?,
9736            )),
9737            500u16..=599u16 => Err(Error::ErrorResponse(
9738                ResponseValue::from_response(response).await?,
9739            )),
9740            _ => Err(Error::UnexpectedResponse(response)),
9741        }
9742    }
9743
9744    ///Return a test error
9745    ///
9746    ///Always returns an error response incorporating the supplied parameters,
9747    /// useful for testing error handling.
9748    ///
9749    ///Sends a `POST` request to `/rc/error`
9750    ///
9751    ///Arguments:
9752    /// - `async_`: Run the command asynchronously. Returns a job id
9753    ///   immediately.
9754    /// - `params`: Additional arbitrary parameters allowed.
9755    pub async fn rc_error<'a>(
9756        &'a self,
9757        async_: Option<bool>,
9758        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9759    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
9760        let url = format!("{}/rc/error", self.baseurl,);
9761        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9762        header_map.append(
9763            ::reqwest::header::HeaderName::from_static("api-version"),
9764            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9765        );
9766        #[allow(unused_mut)]
9767        let mut request = self
9768            .client
9769            .post(url)
9770            .header(
9771                ::reqwest::header::ACCEPT,
9772                ::reqwest::header::HeaderValue::from_static("application/json"),
9773            )
9774            .query(&progenitor_client::QueryParam::new("_async", &async_))
9775            .query(&progenitor_client::QueryParam::new("params", &params))
9776            .headers(header_map)
9777            .build()?;
9778        let info = OperationInfo {
9779            operation_id: "rc_error",
9780        };
9781        self.pre(&mut request, &info).await?;
9782        let result = self.exec(request, &info).await;
9783        self.post(&result, &info).await?;
9784        let response = result?;
9785        match response.status().as_u16() {
9786            200u16 => Ok(ResponseValue::empty(response)),
9787            400u16..=499u16 => Err(Error::ErrorResponse(
9788                ResponseValue::from_response(response).await?,
9789            )),
9790            500u16..=599u16 => Err(Error::ErrorResponse(
9791                ResponseValue::from_response(response).await?,
9792            )),
9793            _ => Err(Error::UnexpectedResponse(response)),
9794        }
9795    }
9796
9797    ///List RC commands
9798    ///
9799    ///Returns metadata about every available RC command, including whether
9800    /// authentication is required.
9801    ///
9802    ///Sends a `POST` request to `/rc/list`
9803    ///
9804    ///Arguments:
9805    /// - `async_`: Run the command asynchronously. Returns a job id
9806    ///   immediately.
9807    /// - `group`: Assign the request to a custom stats group.
9808    pub async fn rc_list<'a>(
9809        &'a self,
9810        async_: Option<bool>,
9811        group: Option<&'a str>,
9812    ) -> Result<ResponseValue<types::RcListResponse>, Error<types::RcError>> {
9813        let url = format!("{}/rc/list", self.baseurl,);
9814        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9815        header_map.append(
9816            ::reqwest::header::HeaderName::from_static("api-version"),
9817            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9818        );
9819        #[allow(unused_mut)]
9820        let mut request = self
9821            .client
9822            .post(url)
9823            .header(
9824                ::reqwest::header::ACCEPT,
9825                ::reqwest::header::HeaderValue::from_static("application/json"),
9826            )
9827            .query(&progenitor_client::QueryParam::new("_async", &async_))
9828            .query(&progenitor_client::QueryParam::new("_group", &group))
9829            .headers(header_map)
9830            .build()?;
9831        let info = OperationInfo {
9832            operation_id: "rc_list",
9833        };
9834        self.pre(&mut request, &info).await?;
9835        let result = self.exec(request, &info).await;
9836        self.post(&result, &info).await?;
9837        let response = result?;
9838        match response.status().as_u16() {
9839            200u16 => ResponseValue::from_response(response).await,
9840            400u16..=499u16 => Err(Error::ErrorResponse(
9841                ResponseValue::from_response(response).await?,
9842            )),
9843            500u16..=599u16 => Err(Error::ErrorResponse(
9844                ResponseValue::from_response(response).await?,
9845            )),
9846            _ => Err(Error::UnexpectedResponse(response)),
9847        }
9848    }
9849
9850    ///Run backend command
9851    ///
9852    ///Invokes a backend-specific management command against an optional
9853    /// remote.
9854    ///
9855    ///Sends a `POST` request to `/backend/command`
9856    ///
9857    ///Arguments:
9858    /// - `async_`: Run the command asynchronously. Returns a job id
9859    ///   immediately.
9860    /// - `group`: Assign the request to a custom stats group.
9861    /// - `arg`: Optional positional arguments for the backend command.
9862    /// - `command`: Backend-specific command to invoke.
9863    /// - `fs`: Remote name or path the backend command should target.
9864    /// - `opt`: Backend command options encoded as a JSON string.
9865    pub async fn backend_command<'a>(
9866        &'a self,
9867        async_: Option<bool>,
9868        group: Option<&'a str>,
9869        arg: Option<&'a ::std::vec::Vec<::std::string::String>>,
9870        command: &'a str,
9871        fs: Option<&'a str>,
9872        opt: Option<&'a str>,
9873    ) -> Result<ResponseValue<types::BackendCommandResponse>, Error<types::RcError>> {
9874        let url = format!("{}/backend/command", 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("arg", &arg))
9891            .query(&progenitor_client::QueryParam::new("command", &command))
9892            .query(&progenitor_client::QueryParam::new("fs", &fs))
9893            .query(&progenitor_client::QueryParam::new("opt", &opt))
9894            .headers(header_map)
9895            .build()?;
9896        let info = OperationInfo {
9897            operation_id: "backend_command",
9898        };
9899        self.pre(&mut request, &info).await?;
9900        let result = self.exec(request, &info).await;
9901        self.post(&result, &info).await?;
9902        let response = result?;
9903        match response.status().as_u16() {
9904            200u16 => ResponseValue::from_response(response).await,
9905            400u16..=499u16 => Err(Error::ErrorResponse(
9906                ResponseValue::from_response(response).await?,
9907            )),
9908            500u16..=599u16 => Err(Error::ErrorResponse(
9909                ResponseValue::from_response(response).await?,
9910            )),
9911            _ => Err(Error::UnexpectedResponse(response)),
9912        }
9913    }
9914
9915    ///Expire cache entries
9916    ///
9917    ///Drops cached directory entries, and optionally cached file data, for the
9918    /// cache backend.
9919    ///
9920    ///Sends a `POST` request to `/cache/expire`
9921    ///
9922    ///Arguments:
9923    /// - `async_`: Run the command asynchronously. Returns a job id
9924    ///   immediately.
9925    /// - `group`: Assign the request to a custom stats group.
9926    /// - `remote`: Remote path to expire from the cache, e.g.
9927    ///   `remote:path/to/dir`.
9928    /// - `with_data`: Set to true to drop cached chunk data along with
9929    ///   directory entries.
9930    pub async fn cache_expire<'a>(
9931        &'a self,
9932        async_: Option<bool>,
9933        group: Option<&'a str>,
9934        remote: &'a str,
9935        with_data: Option<bool>,
9936    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
9937        let url = format!("{}/cache/expire", self.baseurl,);
9938        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9939        header_map.append(
9940            ::reqwest::header::HeaderName::from_static("api-version"),
9941            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9942        );
9943        #[allow(unused_mut)]
9944        let mut request = self
9945            .client
9946            .post(url)
9947            .header(
9948                ::reqwest::header::ACCEPT,
9949                ::reqwest::header::HeaderValue::from_static("application/json"),
9950            )
9951            .query(&progenitor_client::QueryParam::new("_async", &async_))
9952            .query(&progenitor_client::QueryParam::new("_group", &group))
9953            .query(&progenitor_client::QueryParam::new("remote", &remote))
9954            .query(&progenitor_client::QueryParam::new("withData", &with_data))
9955            .headers(header_map)
9956            .build()?;
9957        let info = OperationInfo {
9958            operation_id: "cache_expire",
9959        };
9960        self.pre(&mut request, &info).await?;
9961        let result = self.exec(request, &info).await;
9962        self.post(&result, &info).await?;
9963        let response = result?;
9964        match response.status().as_u16() {
9965            200u16 => Ok(ResponseValue::empty(response)),
9966            400u16..=499u16 => Err(Error::ErrorResponse(
9967                ResponseValue::from_response(response).await?,
9968            )),
9969            500u16..=599u16 => Err(Error::ErrorResponse(
9970                ResponseValue::from_response(response).await?,
9971            )),
9972            _ => Err(Error::UnexpectedResponse(response)),
9973        }
9974    }
9975
9976    ///Prefetch cache chunks
9977    ///
9978    ///Ensures specified file chunks are cached locally for a cache remote.
9979    ///
9980    ///Sends a `POST` request to `/cache/fetch`
9981    ///
9982    ///Arguments:
9983    /// - `async_`: Run the command asynchronously. Returns a job id
9984    ///   immediately.
9985    /// - `group`: Assign the request to a custom stats group.
9986    /// - `chunks`: Comma-separated chunk specifier list (e.g. `0:10,25:30`)
9987    ///   describing file pieces to prefetch.
9988    /// - `params`: Additional arbitrary parameters allowed.
9989    pub async fn cache_fetch<'a>(
9990        &'a self,
9991        async_: Option<bool>,
9992        group: Option<&'a str>,
9993        chunks: Option<&'a str>,
9994        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
9995    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
9996        let url = format!("{}/cache/fetch", self.baseurl,);
9997        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9998        header_map.append(
9999            ::reqwest::header::HeaderName::from_static("api-version"),
10000            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10001        );
10002        #[allow(unused_mut)]
10003        let mut request = self
10004            .client
10005            .post(url)
10006            .header(
10007                ::reqwest::header::ACCEPT,
10008                ::reqwest::header::HeaderValue::from_static("application/json"),
10009            )
10010            .query(&progenitor_client::QueryParam::new("_async", &async_))
10011            .query(&progenitor_client::QueryParam::new("_group", &group))
10012            .query(&progenitor_client::QueryParam::new("chunks", &chunks))
10013            .query(&progenitor_client::QueryParam::new("params", &params))
10014            .headers(header_map)
10015            .build()?;
10016        let info = OperationInfo {
10017            operation_id: "cache_fetch",
10018        };
10019        self.pre(&mut request, &info).await?;
10020        let result = self.exec(request, &info).await;
10021        self.post(&result, &info).await?;
10022        let response = result?;
10023        match response.status().as_u16() {
10024            200u16 => Ok(ResponseValue::empty(response)),
10025            400u16..=499u16 => Err(Error::ErrorResponse(
10026                ResponseValue::from_response(response).await?,
10027            )),
10028            500u16..=599u16 => Err(Error::ErrorResponse(
10029                ResponseValue::from_response(response).await?,
10030            )),
10031            _ => Err(Error::UnexpectedResponse(response)),
10032        }
10033    }
10034
10035    ///Show cache stats
10036    ///
10037    ///Returns runtime statistics for the cache backend.
10038    ///
10039    ///Sends a `POST` request to `/cache/stats`
10040    ///
10041    ///Arguments:
10042    /// - `async_`: Run the command asynchronously. Returns a job id
10043    ///   immediately.
10044    /// - `group`: Assign the request to a custom stats group.
10045    pub async fn cache_stats<'a>(
10046        &'a self,
10047        async_: Option<bool>,
10048        group: Option<&'a str>,
10049    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10050        let url = format!("{}/cache/stats", self.baseurl,);
10051        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10052        header_map.append(
10053            ::reqwest::header::HeaderName::from_static("api-version"),
10054            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10055        );
10056        #[allow(unused_mut)]
10057        let mut request = self
10058            .client
10059            .post(url)
10060            .header(
10061                ::reqwest::header::ACCEPT,
10062                ::reqwest::header::HeaderValue::from_static("application/json"),
10063            )
10064            .query(&progenitor_client::QueryParam::new("_async", &async_))
10065            .query(&progenitor_client::QueryParam::new("_group", &group))
10066            .headers(header_map)
10067            .build()?;
10068        let info = OperationInfo {
10069            operation_id: "cache_stats",
10070        };
10071        self.pre(&mut request, &info).await?;
10072        let result = self.exec(request, &info).await;
10073        self.post(&result, &info).await?;
10074        let response = result?;
10075        match response.status().as_u16() {
10076            200u16 => Ok(ResponseValue::empty(response)),
10077            400u16..=499u16 => Err(Error::ErrorResponse(
10078                ResponseValue::from_response(response).await?,
10079            )),
10080            500u16..=599u16 => Err(Error::ErrorResponse(
10081                ResponseValue::from_response(response).await?,
10082            )),
10083            _ => Err(Error::UnexpectedResponse(response)),
10084        }
10085    }
10086
10087    ///Create remote configuration
10088    ///
10089    ///Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
10090    ///
10091    ///Sends a `POST` request to `/config/create`
10092    ///
10093    ///Arguments:
10094    /// - `async_`: Run the command asynchronously. Returns a job id
10095    ///   immediately.
10096    /// - `group`: Assign the request to a custom stats group.
10097    /// - `name`: Name of the new remote configuration.
10098    /// - `opt`: Optional JSON object controlling interactive behaviour (e.g.
10099    ///   `obscure`, `continue`).
10100    /// - `parameters`: JSON object of configuration key/value pairs required
10101    ///   for the remote.
10102    /// - `type_`: Backend type identifier, such as `drive`, `s3`, or `dropbox`.
10103    pub async fn config_create<'a>(
10104        &'a self,
10105        async_: Option<bool>,
10106        group: Option<&'a str>,
10107        name: &'a str,
10108        opt: Option<&'a str>,
10109        parameters: &'a str,
10110        type_: &'a str,
10111    ) -> Result<
10112        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10113        Error<types::RcError>,
10114    > {
10115        let url = format!("{}/config/create", self.baseurl,);
10116        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10117        header_map.append(
10118            ::reqwest::header::HeaderName::from_static("api-version"),
10119            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10120        );
10121        #[allow(unused_mut)]
10122        let mut request = self
10123            .client
10124            .post(url)
10125            .header(
10126                ::reqwest::header::ACCEPT,
10127                ::reqwest::header::HeaderValue::from_static("application/json"),
10128            )
10129            .query(&progenitor_client::QueryParam::new("_async", &async_))
10130            .query(&progenitor_client::QueryParam::new("_group", &group))
10131            .query(&progenitor_client::QueryParam::new("name", &name))
10132            .query(&progenitor_client::QueryParam::new("opt", &opt))
10133            .query(&progenitor_client::QueryParam::new(
10134                "parameters",
10135                &parameters,
10136            ))
10137            .query(&progenitor_client::QueryParam::new("type", &type_))
10138            .headers(header_map)
10139            .build()?;
10140        let info = OperationInfo {
10141            operation_id: "config_create",
10142        };
10143        self.pre(&mut request, &info).await?;
10144        let result = self.exec(request, &info).await;
10145        self.post(&result, &info).await?;
10146        let response = result?;
10147        match response.status().as_u16() {
10148            200u16 => ResponseValue::from_response(response).await,
10149            400u16..=499u16 => Err(Error::ErrorResponse(
10150                ResponseValue::from_response(response).await?,
10151            )),
10152            500u16..=599u16 => Err(Error::ErrorResponse(
10153                ResponseValue::from_response(response).await?,
10154            )),
10155            _ => Err(Error::UnexpectedResponse(response)),
10156        }
10157    }
10158
10159    ///Delete remote configuration
10160    ///
10161    ///Removes an existing remote from `rclone.conf`.
10162    ///
10163    ///Sends a `POST` request to `/config/delete`
10164    ///
10165    ///Arguments:
10166    /// - `async_`: Run the command asynchronously. Returns a job id
10167    ///   immediately.
10168    /// - `group`: Assign the request to a custom stats group.
10169    /// - `name`: Name of the remote configuration to delete.
10170    pub async fn config_delete<'a>(
10171        &'a self,
10172        async_: Option<bool>,
10173        group: Option<&'a str>,
10174        name: &'a str,
10175    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10176        let url = format!("{}/config/delete", self.baseurl,);
10177        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10178        header_map.append(
10179            ::reqwest::header::HeaderName::from_static("api-version"),
10180            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10181        );
10182        #[allow(unused_mut)]
10183        let mut request = self
10184            .client
10185            .post(url)
10186            .header(
10187                ::reqwest::header::ACCEPT,
10188                ::reqwest::header::HeaderValue::from_static("application/json"),
10189            )
10190            .query(&progenitor_client::QueryParam::new("_async", &async_))
10191            .query(&progenitor_client::QueryParam::new("_group", &group))
10192            .query(&progenitor_client::QueryParam::new("name", &name))
10193            .headers(header_map)
10194            .build()?;
10195        let info = OperationInfo {
10196            operation_id: "config_delete",
10197        };
10198        self.pre(&mut request, &info).await?;
10199        let result = self.exec(request, &info).await;
10200        self.post(&result, &info).await?;
10201        let response = result?;
10202        match response.status().as_u16() {
10203            200u16 => Ok(ResponseValue::empty(response)),
10204            400u16..=499u16 => Err(Error::ErrorResponse(
10205                ResponseValue::from_response(response).await?,
10206            )),
10207            500u16..=599u16 => Err(Error::ErrorResponse(
10208                ResponseValue::from_response(response).await?,
10209            )),
10210            _ => Err(Error::UnexpectedResponse(response)),
10211        }
10212    }
10213
10214    ///Dump configuration
10215    ///
10216    ///Returns the contents of the config file as a JSON object keyed by remote
10217    /// name.
10218    ///
10219    ///Sends a `POST` request to `/config/dump`
10220    ///
10221    ///Arguments:
10222    /// - `async_`: Run the command asynchronously. Returns a job id
10223    ///   immediately.
10224    /// - `group`: Assign the request to a custom stats group.
10225    pub async fn config_dump<'a>(
10226        &'a self,
10227        async_: Option<bool>,
10228        group: Option<&'a str>,
10229    ) -> Result<
10230        ResponseValue<
10231            ::std::collections::HashMap<
10232                ::std::string::String,
10233                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
10234            >,
10235        >,
10236        Error<types::RcError>,
10237    > {
10238        let url = format!("{}/config/dump", self.baseurl,);
10239        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10240        header_map.append(
10241            ::reqwest::header::HeaderName::from_static("api-version"),
10242            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10243        );
10244        #[allow(unused_mut)]
10245        let mut request = self
10246            .client
10247            .post(url)
10248            .header(
10249                ::reqwest::header::ACCEPT,
10250                ::reqwest::header::HeaderValue::from_static("application/json"),
10251            )
10252            .query(&progenitor_client::QueryParam::new("_async", &async_))
10253            .query(&progenitor_client::QueryParam::new("_group", &group))
10254            .headers(header_map)
10255            .build()?;
10256        let info = OperationInfo {
10257            operation_id: "config_dump",
10258        };
10259        self.pre(&mut request, &info).await?;
10260        let result = self.exec(request, &info).await;
10261        self.post(&result, &info).await?;
10262        let response = result?;
10263        match response.status().as_u16() {
10264            200u16 => ResponseValue::from_response(response).await,
10265            400u16..=499u16 => Err(Error::ErrorResponse(
10266                ResponseValue::from_response(response).await?,
10267            )),
10268            500u16..=599u16 => Err(Error::ErrorResponse(
10269                ResponseValue::from_response(response).await?,
10270            )),
10271            _ => Err(Error::UnexpectedResponse(response)),
10272        }
10273    }
10274
10275    ///Get remote configuration
10276    ///
10277    ///Returns the key/value settings for a single remote.
10278    ///
10279    ///Sends a `POST` request to `/config/get`
10280    ///
10281    ///Arguments:
10282    /// - `async_`: Run the command asynchronously. Returns a job id
10283    ///   immediately.
10284    /// - `group`: Assign the request to a custom stats group.
10285    /// - `name`: Name of the remote configuration to fetch.
10286    pub async fn config_get<'a>(
10287        &'a self,
10288        async_: Option<bool>,
10289        group: Option<&'a str>,
10290        name: &'a str,
10291    ) -> Result<ResponseValue<types::ConfigGetResponse>, Error<types::RcError>> {
10292        let url = format!("{}/config/get", self.baseurl,);
10293        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10294        header_map.append(
10295            ::reqwest::header::HeaderName::from_static("api-version"),
10296            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10297        );
10298        #[allow(unused_mut)]
10299        let mut request = self
10300            .client
10301            .post(url)
10302            .header(
10303                ::reqwest::header::ACCEPT,
10304                ::reqwest::header::HeaderValue::from_static("application/json"),
10305            )
10306            .query(&progenitor_client::QueryParam::new("_async", &async_))
10307            .query(&progenitor_client::QueryParam::new("_group", &group))
10308            .query(&progenitor_client::QueryParam::new("name", &name))
10309            .headers(header_map)
10310            .build()?;
10311        let info = OperationInfo {
10312            operation_id: "config_get",
10313        };
10314        self.pre(&mut request, &info).await?;
10315        let result = self.exec(request, &info).await;
10316        self.post(&result, &info).await?;
10317        let response = result?;
10318        match response.status().as_u16() {
10319            200u16 => ResponseValue::from_response(response).await,
10320            400u16..=499u16 => Err(Error::ErrorResponse(
10321                ResponseValue::from_response(response).await?,
10322            )),
10323            500u16..=599u16 => Err(Error::ErrorResponse(
10324                ResponseValue::from_response(response).await?,
10325            )),
10326            _ => Err(Error::UnexpectedResponse(response)),
10327        }
10328    }
10329
10330    ///List configured remotes
10331    ///
10332    ///Returns the names of all remotes defined in the config file.
10333    ///
10334    ///Sends a `POST` request to `/config/listremotes`
10335    ///
10336    ///Arguments:
10337    /// - `async_`: Run the command asynchronously. Returns a job id
10338    ///   immediately.
10339    /// - `group`: Assign the request to a custom stats group.
10340    pub async fn config_listremotes<'a>(
10341        &'a self,
10342        async_: Option<bool>,
10343        group: Option<&'a str>,
10344    ) -> Result<ResponseValue<types::ConfigListremotesResponse>, Error<types::RcError>> {
10345        let url = format!("{}/config/listremotes", self.baseurl,);
10346        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10347        header_map.append(
10348            ::reqwest::header::HeaderName::from_static("api-version"),
10349            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10350        );
10351        #[allow(unused_mut)]
10352        let mut request = self
10353            .client
10354            .post(url)
10355            .header(
10356                ::reqwest::header::ACCEPT,
10357                ::reqwest::header::HeaderValue::from_static("application/json"),
10358            )
10359            .query(&progenitor_client::QueryParam::new("_async", &async_))
10360            .query(&progenitor_client::QueryParam::new("_group", &group))
10361            .headers(header_map)
10362            .build()?;
10363        let info = OperationInfo {
10364            operation_id: "config_listremotes",
10365        };
10366        self.pre(&mut request, &info).await?;
10367        let result = self.exec(request, &info).await;
10368        self.post(&result, &info).await?;
10369        let response = result?;
10370        match response.status().as_u16() {
10371            200u16 => ResponseValue::from_response(response).await,
10372            400u16..=499u16 => Err(Error::ErrorResponse(
10373                ResponseValue::from_response(response).await?,
10374            )),
10375            500u16..=599u16 => Err(Error::ErrorResponse(
10376                ResponseValue::from_response(response).await?,
10377            )),
10378            _ => Err(Error::UnexpectedResponse(response)),
10379        }
10380    }
10381
10382    ///Update remote secrets
10383    ///
10384    ///Sets obscured password fields for a remote configuration.
10385    ///
10386    ///Sends a `POST` request to `/config/password`
10387    ///
10388    ///Arguments:
10389    /// - `async_`: Run the command asynchronously. Returns a job id
10390    ///   immediately.
10391    /// - `group`: Assign the request to a custom stats group.
10392    /// - `name`: Name of the remote whose secrets should be updated.
10393    /// - `parameters`: JSON object of password answers, typically including
10394    ///   `pass`.
10395    pub async fn config_password<'a>(
10396        &'a self,
10397        async_: Option<bool>,
10398        group: Option<&'a str>,
10399        name: &'a str,
10400        parameters: &'a str,
10401    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10402        let url = format!("{}/config/password", self.baseurl,);
10403        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10404        header_map.append(
10405            ::reqwest::header::HeaderName::from_static("api-version"),
10406            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10407        );
10408        #[allow(unused_mut)]
10409        let mut request = self
10410            .client
10411            .post(url)
10412            .header(
10413                ::reqwest::header::ACCEPT,
10414                ::reqwest::header::HeaderValue::from_static("application/json"),
10415            )
10416            .query(&progenitor_client::QueryParam::new("_async", &async_))
10417            .query(&progenitor_client::QueryParam::new("_group", &group))
10418            .query(&progenitor_client::QueryParam::new("name", &name))
10419            .query(&progenitor_client::QueryParam::new(
10420                "parameters",
10421                &parameters,
10422            ))
10423            .headers(header_map)
10424            .build()?;
10425        let info = OperationInfo {
10426            operation_id: "config_password",
10427        };
10428        self.pre(&mut request, &info).await?;
10429        let result = self.exec(request, &info).await;
10430        self.post(&result, &info).await?;
10431        let response = result?;
10432        match response.status().as_u16() {
10433            200u16 => Ok(ResponseValue::empty(response)),
10434            400u16..=499u16 => Err(Error::ErrorResponse(
10435                ResponseValue::from_response(response).await?,
10436            )),
10437            500u16..=599u16 => Err(Error::ErrorResponse(
10438                ResponseValue::from_response(response).await?,
10439            )),
10440            _ => Err(Error::UnexpectedResponse(response)),
10441        }
10442    }
10443
10444    ///Show config paths
10445    ///
10446    ///Returns the paths to the config file, cache directory, and temporary
10447    /// directory.
10448    ///
10449    ///Sends a `POST` request to `/config/paths`
10450    ///
10451    ///Arguments:
10452    /// - `async_`: Run the command asynchronously. Returns a job id
10453    ///   immediately.
10454    /// - `group`: Assign the request to a custom stats group.
10455    pub async fn config_paths<'a>(
10456        &'a self,
10457        async_: Option<bool>,
10458        group: Option<&'a str>,
10459    ) -> Result<ResponseValue<types::ConfigPathsResponse>, Error<types::RcError>> {
10460        let url = format!("{}/config/paths", self.baseurl,);
10461        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10462        header_map.append(
10463            ::reqwest::header::HeaderName::from_static("api-version"),
10464            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10465        );
10466        #[allow(unused_mut)]
10467        let mut request = self
10468            .client
10469            .post(url)
10470            .header(
10471                ::reqwest::header::ACCEPT,
10472                ::reqwest::header::HeaderValue::from_static("application/json"),
10473            )
10474            .query(&progenitor_client::QueryParam::new("_async", &async_))
10475            .query(&progenitor_client::QueryParam::new("_group", &group))
10476            .headers(header_map)
10477            .build()?;
10478        let info = OperationInfo {
10479            operation_id: "config_paths",
10480        };
10481        self.pre(&mut request, &info).await?;
10482        let result = self.exec(request, &info).await;
10483        self.post(&result, &info).await?;
10484        let response = result?;
10485        match response.status().as_u16() {
10486            200u16 => ResponseValue::from_response(response).await,
10487            400u16..=499u16 => Err(Error::ErrorResponse(
10488                ResponseValue::from_response(response).await?,
10489            )),
10490            500u16..=599u16 => Err(Error::ErrorResponse(
10491                ResponseValue::from_response(response).await?,
10492            )),
10493            _ => Err(Error::UnexpectedResponse(response)),
10494        }
10495    }
10496
10497    ///List backend providers
10498    ///
10499    ///Returns metadata describing each supported storage provider.
10500    ///
10501    ///Sends a `POST` request to `/config/providers`
10502    ///
10503    ///Arguments:
10504    /// - `async_`: Run the command asynchronously. Returns a job id
10505    ///   immediately.
10506    /// - `group`: Assign the request to a custom stats group.
10507    pub async fn config_providers<'a>(
10508        &'a self,
10509        async_: Option<bool>,
10510        group: Option<&'a str>,
10511    ) -> Result<ResponseValue<types::ConfigProvidersResponse>, Error<types::RcError>> {
10512        let url = format!("{}/config/providers", self.baseurl,);
10513        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10514        header_map.append(
10515            ::reqwest::header::HeaderName::from_static("api-version"),
10516            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10517        );
10518        #[allow(unused_mut)]
10519        let mut request = self
10520            .client
10521            .post(url)
10522            .header(
10523                ::reqwest::header::ACCEPT,
10524                ::reqwest::header::HeaderValue::from_static("application/json"),
10525            )
10526            .query(&progenitor_client::QueryParam::new("_async", &async_))
10527            .query(&progenitor_client::QueryParam::new("_group", &group))
10528            .headers(header_map)
10529            .build()?;
10530        let info = OperationInfo {
10531            operation_id: "config_providers",
10532        };
10533        self.pre(&mut request, &info).await?;
10534        let result = self.exec(request, &info).await;
10535        self.post(&result, &info).await?;
10536        let response = result?;
10537        match response.status().as_u16() {
10538            200u16 => ResponseValue::from_response(response).await,
10539            400u16..=499u16 => Err(Error::ErrorResponse(
10540                ResponseValue::from_response(response).await?,
10541            )),
10542            500u16..=599u16 => Err(Error::ErrorResponse(
10543                ResponseValue::from_response(response).await?,
10544            )),
10545            _ => Err(Error::UnexpectedResponse(response)),
10546        }
10547    }
10548
10549    ///Set config path
10550    ///
10551    ///Points rclone at a specific `rclone.conf` file.
10552    ///
10553    ///Sends a `POST` request to `/config/setpath`
10554    ///
10555    ///Arguments:
10556    /// - `async_`: Run the command asynchronously. Returns a job id
10557    ///   immediately.
10558    /// - `group`: Assign the request to a custom stats group.
10559    /// - `path`: Absolute path to the `rclone.conf` file that rclone should
10560    ///   use.
10561    pub async fn config_setpath<'a>(
10562        &'a self,
10563        async_: Option<bool>,
10564        group: Option<&'a str>,
10565        path: &'a str,
10566    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10567        let url = format!("{}/config/setpath", self.baseurl,);
10568        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10569        header_map.append(
10570            ::reqwest::header::HeaderName::from_static("api-version"),
10571            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10572        );
10573        #[allow(unused_mut)]
10574        let mut request = self
10575            .client
10576            .post(url)
10577            .header(
10578                ::reqwest::header::ACCEPT,
10579                ::reqwest::header::HeaderValue::from_static("application/json"),
10580            )
10581            .query(&progenitor_client::QueryParam::new("_async", &async_))
10582            .query(&progenitor_client::QueryParam::new("_group", &group))
10583            .query(&progenitor_client::QueryParam::new("path", &path))
10584            .headers(header_map)
10585            .build()?;
10586        let info = OperationInfo {
10587            operation_id: "config_setpath",
10588        };
10589        self.pre(&mut request, &info).await?;
10590        let result = self.exec(request, &info).await;
10591        self.post(&result, &info).await?;
10592        let response = result?;
10593        match response.status().as_u16() {
10594            200u16 => Ok(ResponseValue::empty(response)),
10595            400u16..=499u16 => Err(Error::ErrorResponse(
10596                ResponseValue::from_response(response).await?,
10597            )),
10598            500u16..=599u16 => Err(Error::ErrorResponse(
10599                ResponseValue::from_response(response).await?,
10600            )),
10601            _ => Err(Error::UnexpectedResponse(response)),
10602        }
10603    }
10604
10605    ///Unlock encrypted config
10606    ///
10607    ///Unlocks the configuration file using the provided password.
10608    ///
10609    ///Sends a `POST` request to `/config/unlock`
10610    ///
10611    ///Arguments:
10612    /// - `async_`: Run the command asynchronously. Returns a job id
10613    ///   immediately.
10614    /// - `group`: Assign the request to a custom stats group.
10615    /// - `config_password`: Password used to unlock an encrypted config file.
10616    pub async fn config_unlock<'a>(
10617        &'a self,
10618        async_: Option<bool>,
10619        group: Option<&'a str>,
10620        config_password: &'a str,
10621    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
10622        let url = format!("{}/config/unlock", self.baseurl,);
10623        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10624        header_map.append(
10625            ::reqwest::header::HeaderName::from_static("api-version"),
10626            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10627        );
10628        #[allow(unused_mut)]
10629        let mut request = self
10630            .client
10631            .post(url)
10632            .header(
10633                ::reqwest::header::ACCEPT,
10634                ::reqwest::header::HeaderValue::from_static("application/json"),
10635            )
10636            .query(&progenitor_client::QueryParam::new("_async", &async_))
10637            .query(&progenitor_client::QueryParam::new("_group", &group))
10638            .query(&progenitor_client::QueryParam::new(
10639                "configPassword",
10640                &config_password,
10641            ))
10642            .headers(header_map)
10643            .build()?;
10644        let info = OperationInfo {
10645            operation_id: "config_unlock",
10646        };
10647        self.pre(&mut request, &info).await?;
10648        let result = self.exec(request, &info).await;
10649        self.post(&result, &info).await?;
10650        let response = result?;
10651        match response.status().as_u16() {
10652            200u16 => Ok(ResponseValue::empty(response)),
10653            400u16..=499u16 => Err(Error::ErrorResponse(
10654                ResponseValue::from_response(response).await?,
10655            )),
10656            500u16..=599u16 => Err(Error::ErrorResponse(
10657                ResponseValue::from_response(response).await?,
10658            )),
10659            _ => Err(Error::UnexpectedResponse(response)),
10660        }
10661    }
10662
10663    ///Update remote configuration
10664    ///
10665    ///Updates an existing remote with new parameter values.
10666    ///
10667    ///Sends a `POST` request to `/config/update`
10668    ///
10669    ///Arguments:
10670    /// - `async_`: Run the command asynchronously. Returns a job id
10671    ///   immediately.
10672    /// - `group`: Assign the request to a custom stats group.
10673    /// - `name`: Name of the remote configuration to update.
10674    /// - `opt`: Optional JSON object controlling update behaviour (e.g.
10675    ///   `obscure`, `continue`).
10676    /// - `parameters`: JSON object of configuration key/value pairs to apply to
10677    ///   the remote.
10678    pub async fn config_update<'a>(
10679        &'a self,
10680        async_: Option<bool>,
10681        group: Option<&'a str>,
10682        name: &'a str,
10683        opt: Option<&'a str>,
10684        parameters: &'a str,
10685    ) -> Result<
10686        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
10687        Error<types::RcError>,
10688    > {
10689        let url = format!("{}/config/update", self.baseurl,);
10690        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10691        header_map.append(
10692            ::reqwest::header::HeaderName::from_static("api-version"),
10693            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10694        );
10695        #[allow(unused_mut)]
10696        let mut request = self
10697            .client
10698            .post(url)
10699            .header(
10700                ::reqwest::header::ACCEPT,
10701                ::reqwest::header::HeaderValue::from_static("application/json"),
10702            )
10703            .query(&progenitor_client::QueryParam::new("_async", &async_))
10704            .query(&progenitor_client::QueryParam::new("_group", &group))
10705            .query(&progenitor_client::QueryParam::new("name", &name))
10706            .query(&progenitor_client::QueryParam::new("opt", &opt))
10707            .query(&progenitor_client::QueryParam::new(
10708                "parameters",
10709                &parameters,
10710            ))
10711            .headers(header_map)
10712            .build()?;
10713        let info = OperationInfo {
10714            operation_id: "config_update",
10715        };
10716        self.pre(&mut request, &info).await?;
10717        let result = self.exec(request, &info).await;
10718        self.post(&result, &info).await?;
10719        let response = result?;
10720        match response.status().as_u16() {
10721            200u16 => ResponseValue::from_response(response).await,
10722            400u16..=499u16 => Err(Error::ErrorResponse(
10723                ResponseValue::from_response(response).await?,
10724            )),
10725            500u16..=599u16 => Err(Error::ErrorResponse(
10726                ResponseValue::from_response(response).await?,
10727            )),
10728            _ => Err(Error::UnexpectedResponse(response)),
10729        }
10730    }
10731
10732    ///Report rclone version
10733    ///
10734    ///Returns the running rclone version, build metadata, and Go runtime
10735    /// details.
10736    ///
10737    ///Sends a `POST` request to `/core/version`
10738    ///
10739    ///Arguments:
10740    /// - `async_`: Run the command asynchronously. Returns a job id
10741    ///   immediately.
10742    /// - `group`: Assign the request to a custom stats group.
10743    pub async fn core_version<'a>(
10744        &'a self,
10745        async_: Option<bool>,
10746        group: Option<&'a str>,
10747    ) -> Result<ResponseValue<types::CoreVersionResponse>, Error<types::RcError>> {
10748        let url = format!("{}/core/version", self.baseurl,);
10749        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10750        header_map.append(
10751            ::reqwest::header::HeaderName::from_static("api-version"),
10752            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10753        );
10754        #[allow(unused_mut)]
10755        let mut request = self
10756            .client
10757            .post(url)
10758            .header(
10759                ::reqwest::header::ACCEPT,
10760                ::reqwest::header::HeaderValue::from_static("application/json"),
10761            )
10762            .query(&progenitor_client::QueryParam::new("_async", &async_))
10763            .query(&progenitor_client::QueryParam::new("_group", &group))
10764            .headers(header_map)
10765            .build()?;
10766        let info = OperationInfo {
10767            operation_id: "core_version",
10768        };
10769        self.pre(&mut request, &info).await?;
10770        let result = self.exec(request, &info).await;
10771        self.post(&result, &info).await?;
10772        let response = result?;
10773        match response.status().as_u16() {
10774            200u16 => ResponseValue::from_response(response).await,
10775            400u16..=499u16 => Err(Error::ErrorResponse(
10776                ResponseValue::from_response(response).await?,
10777            )),
10778            500u16..=599u16 => Err(Error::ErrorResponse(
10779                ResponseValue::from_response(response).await?,
10780            )),
10781            _ => Err(Error::UnexpectedResponse(response)),
10782        }
10783    }
10784
10785    ///Current stats snapshot
10786    ///
10787    ///Returns active transfer statistics including bytes transferred, speed,
10788    /// and error counts.
10789    ///
10790    ///Sends a `POST` request to `/core/stats`
10791    ///
10792    ///Arguments:
10793    /// - `async_`: Run the command asynchronously. Returns a job id
10794    ///   immediately.
10795    /// - `group`: Assign the request to a custom stats group.
10796    /// - `group`: Stats group identifier to return a snapshot for. Leave unset
10797    ///   to include all groups.
10798    /// - `short`: When true, omit the `transferring` and `checking` arrays from
10799    ///   the response.
10800    pub async fn core_stats<'a>(
10801        &'a self,
10802        async_: Option<bool>,
10803        _group: Option<&'a str>,
10804        group: Option<&'a str>,
10805        short: Option<bool>
10806    ) -> Result<ResponseValue<types::CoreStatsResponse>, Error<types::RcError>> {
10807        let url = format!("{}/core/stats", self.baseurl,);
10808        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10809        header_map.append(
10810            ::reqwest::header::HeaderName::from_static("api-version"),
10811            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10812        );
10813        #[allow(unused_mut)]
10814        let mut request = self
10815            .client
10816            .post(url)
10817            .header(
10818                ::reqwest::header::ACCEPT,
10819                ::reqwest::header::HeaderValue::from_static("application/json"),
10820            )
10821            .query(&progenitor_client::QueryParam::new("_async", &async_))
10822            .query(&progenitor_client::QueryParam::new("_group", &group))
10823            .query(&progenitor_client::QueryParam::new("group", &group))
10824            .query(&progenitor_client::QueryParam::new("short", &short))
10825            .headers(header_map)
10826            .build()?;
10827        let info = OperationInfo {
10828            operation_id: "core_stats",
10829        };
10830        self.pre(&mut request, &info).await?;
10831        let result = self.exec(request, &info).await;
10832        self.post(&result, &info).await?;
10833        let response = result?;
10834        match response.status().as_u16() {
10835            200u16 => ResponseValue::from_response(response).await,
10836            400u16..=499u16 => Err(Error::ErrorResponse(
10837                ResponseValue::from_response(response).await?,
10838            )),
10839            500u16..=599u16 => Err(Error::ErrorResponse(
10840                ResponseValue::from_response(response).await?,
10841            )),
10842            _ => Err(Error::UnexpectedResponse(response)),
10843        }
10844    }
10845
10846    ///Run batch of commands
10847    ///
10848    ///Run a batch of rclone rc commands concurrently.
10849    ///
10850    ///Sends a `POST` request to `/job/batch`
10851    ///
10852    ///Arguments:
10853    /// - `async_`: Run the command asynchronously. Returns a job id
10854    ///   immediately.
10855    /// - `concurrency`: Do this many commands concurrently. Defaults to
10856    ///   --transfers if not set.
10857    /// - `inputs`: List of inputs to the commands with an extra _path
10858    ///   parameter.
10859    pub async fn job_batch<'a>(
10860        &'a self,
10861        async_: Option<bool>,
10862        concurrency: Option<i64>,
10863        inputs: Option<&'a ::std::vec::Vec<types::JobBatchInputsItem>>,
10864    ) -> Result<ResponseValue<types::JobBatchResponse>, Error<types::RcError>> {
10865        let url = format!("{}/job/batch", self.baseurl,);
10866        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10867        header_map.append(
10868            ::reqwest::header::HeaderName::from_static("api-version"),
10869            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10870        );
10871        #[allow(unused_mut)]
10872        let mut request = self
10873            .client
10874            .post(url)
10875            .header(
10876                ::reqwest::header::ACCEPT,
10877                ::reqwest::header::HeaderValue::from_static("application/json"),
10878            )
10879            .query(&progenitor_client::QueryParam::new("_async", &async_))
10880            .query(&progenitor_client::QueryParam::new(
10881                "concurrency",
10882                &concurrency,
10883            ))
10884            .query(&progenitor_client::QueryParam::new("inputs", &inputs))
10885            .headers(header_map)
10886            .build()?;
10887        let info = OperationInfo {
10888            operation_id: "job_batch",
10889        };
10890        self.pre(&mut request, &info).await?;
10891        let result = self.exec(request, &info).await;
10892        self.post(&result, &info).await?;
10893        let response = result?;
10894        match response.status().as_u16() {
10895            200u16 => ResponseValue::from_response(response).await,
10896            400u16..=499u16 => Err(Error::ErrorResponse(
10897                ResponseValue::from_response(response).await?,
10898            )),
10899            500u16..=599u16 => Err(Error::ErrorResponse(
10900                ResponseValue::from_response(response).await?,
10901            )),
10902            _ => Err(Error::UnexpectedResponse(response)),
10903        }
10904    }
10905
10906    ///List jobs
10907    ///
10908    ///Returns identifiers of active and recently completed asynchronous jobs.
10909    ///
10910    ///Sends a `POST` request to `/job/list`
10911    ///
10912    ///Arguments:
10913    /// - `async_`: Run the command asynchronously. Returns a job id
10914    ///   immediately.
10915    pub async fn job_list<'a>(
10916        &'a self,
10917        async_: Option<bool>,
10918    ) -> Result<ResponseValue<types::JobListResponse>, Error<types::RcError>> {
10919        let url = format!("{}/job/list", self.baseurl,);
10920        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10921        header_map.append(
10922            ::reqwest::header::HeaderName::from_static("api-version"),
10923            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10924        );
10925        #[allow(unused_mut)]
10926        let mut request = self
10927            .client
10928            .post(url)
10929            .header(
10930                ::reqwest::header::ACCEPT,
10931                ::reqwest::header::HeaderValue::from_static("application/json"),
10932            )
10933            .query(&progenitor_client::QueryParam::new("_async", &async_))
10934            .headers(header_map)
10935            .build()?;
10936        let info = OperationInfo {
10937            operation_id: "job_list",
10938        };
10939        self.pre(&mut request, &info).await?;
10940        let result = self.exec(request, &info).await;
10941        self.post(&result, &info).await?;
10942        let response = result?;
10943        match response.status().as_u16() {
10944            200u16 => ResponseValue::from_response(response).await,
10945            400u16..=499u16 => Err(Error::ErrorResponse(
10946                ResponseValue::from_response(response).await?,
10947            )),
10948            500u16..=599u16 => Err(Error::ErrorResponse(
10949                ResponseValue::from_response(response).await?,
10950            )),
10951            _ => Err(Error::UnexpectedResponse(response)),
10952        }
10953    }
10954
10955    ///Get job status
10956    ///
10957    ///Returns timing, success state, output, and progress for a specific job.
10958    ///
10959    ///Sends a `POST` request to `/job/status`
10960    ///
10961    ///Arguments:
10962    /// - `async_`: Run the command asynchronously. Returns a job id
10963    ///   immediately.
10964    /// - `jobid`: Numeric identifier of the job to query, as returned from an
10965    ///   async call.
10966    pub async fn job_status<'a>(
10967        &'a self,
10968        async_: Option<bool>,
10969        jobid: f64,
10970    ) -> Result<ResponseValue<types::JobStatusResponse>, Error<types::RcError>> {
10971        let url = format!("{}/job/status", self.baseurl,);
10972        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
10973        header_map.append(
10974            ::reqwest::header::HeaderName::from_static("api-version"),
10975            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
10976        );
10977        #[allow(unused_mut)]
10978        let mut request = self
10979            .client
10980            .post(url)
10981            .header(
10982                ::reqwest::header::ACCEPT,
10983                ::reqwest::header::HeaderValue::from_static("application/json"),
10984            )
10985            .query(&progenitor_client::QueryParam::new("_async", &async_))
10986            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
10987            .headers(header_map)
10988            .build()?;
10989        let info = OperationInfo {
10990            operation_id: "job_status",
10991        };
10992        self.pre(&mut request, &info).await?;
10993        let result = self.exec(request, &info).await;
10994        self.post(&result, &info).await?;
10995        let response = result?;
10996        match response.status().as_u16() {
10997            200u16 => ResponseValue::from_response(response).await,
10998            400u16..=499u16 => Err(Error::ErrorResponse(
10999                ResponseValue::from_response(response).await?,
11000            )),
11001            500u16..=599u16 => Err(Error::ErrorResponse(
11002                ResponseValue::from_response(response).await?,
11003            )),
11004            _ => Err(Error::UnexpectedResponse(response)),
11005        }
11006    }
11007
11008    ///Stop job
11009    ///
11010    ///Attempts to cancel a running job by ID.
11011    ///
11012    ///Sends a `POST` request to `/job/stop`
11013    ///
11014    ///Arguments:
11015    /// - `async_`: Run the command asynchronously. Returns a job id
11016    ///   immediately.
11017    /// - `jobid`: Numeric identifier of the job to cancel.
11018    pub async fn job_stop<'a>(
11019        &'a self,
11020        async_: Option<bool>,
11021        jobid: f64,
11022    ) -> Result<
11023        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11024        Error<types::RcError>,
11025    > {
11026        let url = format!("{}/job/stop", self.baseurl,);
11027        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11028        header_map.append(
11029            ::reqwest::header::HeaderName::from_static("api-version"),
11030            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11031        );
11032        #[allow(unused_mut)]
11033        let mut request = self
11034            .client
11035            .post(url)
11036            .header(
11037                ::reqwest::header::ACCEPT,
11038                ::reqwest::header::HeaderValue::from_static("application/json"),
11039            )
11040            .query(&progenitor_client::QueryParam::new("_async", &async_))
11041            .query(&progenitor_client::QueryParam::new("jobid", &jobid))
11042            .headers(header_map)
11043            .build()?;
11044        let info = OperationInfo {
11045            operation_id: "job_stop",
11046        };
11047        self.pre(&mut request, &info).await?;
11048        let result = self.exec(request, &info).await;
11049        self.post(&result, &info).await?;
11050        let response = result?;
11051        match response.status().as_u16() {
11052            200u16 => ResponseValue::from_response(response).await,
11053            400u16..=499u16 => Err(Error::ErrorResponse(
11054                ResponseValue::from_response(response).await?,
11055            )),
11056            500u16..=599u16 => Err(Error::ErrorResponse(
11057                ResponseValue::from_response(response).await?,
11058            )),
11059            _ => Err(Error::UnexpectedResponse(response)),
11060        }
11061    }
11062
11063    ///Stop jobs in group
11064    ///
11065    ///Cancels all active jobs associated with the provided stats group.
11066    ///
11067    ///Sends a `POST` request to `/job/stopgroup`
11068    ///
11069    ///Arguments:
11070    /// - `async_`: Run the command asynchronously. Returns a job id
11071    ///   immediately.
11072    /// - `group`: Stats group name whose active jobs should be stopped.
11073    pub async fn job_stopgroup<'a>(
11074        &'a self,
11075        async_: Option<bool>,
11076        group: &'a str,
11077    ) -> Result<
11078        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11079        Error<types::RcError>,
11080    > {
11081        let url = format!("{}/job/stopgroup", self.baseurl,);
11082        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11083        header_map.append(
11084            ::reqwest::header::HeaderName::from_static("api-version"),
11085            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11086        );
11087        #[allow(unused_mut)]
11088        let mut request = self
11089            .client
11090            .post(url)
11091            .header(
11092                ::reqwest::header::ACCEPT,
11093                ::reqwest::header::HeaderValue::from_static("application/json"),
11094            )
11095            .query(&progenitor_client::QueryParam::new("_async", &async_))
11096            .query(&progenitor_client::QueryParam::new("group", &group))
11097            .headers(header_map)
11098            .build()?;
11099        let info = OperationInfo {
11100            operation_id: "job_stopgroup",
11101        };
11102        self.pre(&mut request, &info).await?;
11103        let result = self.exec(request, &info).await;
11104        self.post(&result, &info).await?;
11105        let response = result?;
11106        match response.status().as_u16() {
11107            200u16 => ResponseValue::from_response(response).await,
11108            400u16..=499u16 => Err(Error::ErrorResponse(
11109                ResponseValue::from_response(response).await?,
11110            )),
11111            500u16..=599u16 => Err(Error::ErrorResponse(
11112                ResponseValue::from_response(response).await?,
11113            )),
11114            _ => Err(Error::UnexpectedResponse(response)),
11115        }
11116    }
11117
11118    ///List objects
11119    ///
11120    ///Lists objects and directories for a remote path, returning the same
11121    /// fields as `rclone lsjson`.
11122    ///
11123    ///Sends a `POST` request to `/operations/list`
11124    ///
11125    ///Arguments:
11126    /// - `async_`: Run the command asynchronously. Returns a job id
11127    ///   immediately.
11128    /// - `group`: Assign the request to a custom stats group.
11129    /// - `dirs_only`: Set to true to return only directory entries.
11130    /// - `files_only`: Set to true to return only file entries.
11131    /// - `fs`: Remote name or path to list, for example `drive:`.
11132    /// - `hash_types`: Specify one or more hash algorithms to include when
11133    ///   `showHash` is true (e.g. `md5`).
11134    /// - `metadata`: Set to true to include backend-provided metadata maps.
11135    /// - `no_mime_type`: Set to true to omit MIME type detection.
11136    /// - `no_mod_time`: Set to true to omit modification times for faster
11137    ///   listings on some backends.
11138    /// - `opt`: Optional JSON-encoded object of listing flags (e.g. `{
11139    ///   "recurse": true, "showHash": true }`).
11140    /// - `recurse`: Set to true to list directories recursively.
11141    /// - `remote`: Directory path within `fs` to list; leave empty to target
11142    ///   the root.
11143    /// - `show_encrypted`: Set to true to include encrypted names when using
11144    ///   crypt remotes.
11145    /// - `show_hash`: Set to true to include hash digests for each entry.
11146    /// - `show_orig_i_ds`: Set to true to include original backend identifiers
11147    ///   where available.
11148    pub async fn operations_list<'a>(
11149        &'a self,
11150        async_: Option<bool>,
11151        group: Option<&'a str>,
11152        dirs_only: Option<bool>,
11153        files_only: Option<bool>,
11154        fs: &'a str,
11155        hash_types: Option<&'a ::std::vec::Vec<::std::string::String>>,
11156        metadata: Option<bool>,
11157        no_mime_type: Option<bool>,
11158        no_mod_time: Option<bool>,
11159        opt: Option<&'a str>,
11160        recurse: Option<bool>,
11161        remote: &'a str,
11162        show_encrypted: Option<bool>,
11163        show_hash: Option<bool>,
11164        show_orig_i_ds: Option<bool>,
11165    ) -> Result<ResponseValue<types::OperationsListResponse>, Error<types::RcError>> {
11166        let url = format!("{}/operations/list", self.baseurl,);
11167        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11168        header_map.append(
11169            ::reqwest::header::HeaderName::from_static("api-version"),
11170            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11171        );
11172        #[allow(unused_mut)]
11173        let mut request = self
11174            .client
11175            .post(url)
11176            .header(
11177                ::reqwest::header::ACCEPT,
11178                ::reqwest::header::HeaderValue::from_static("application/json"),
11179            )
11180            .query(&progenitor_client::QueryParam::new("_async", &async_))
11181            .query(&progenitor_client::QueryParam::new("_group", &group))
11182            .query(&progenitor_client::QueryParam::new("dirsOnly", &dirs_only))
11183            .query(&progenitor_client::QueryParam::new(
11184                "filesOnly",
11185                &files_only,
11186            ))
11187            .query(&progenitor_client::QueryParam::new("fs", &fs))
11188            .query(&progenitor_client::QueryParam::new(
11189                "hashTypes",
11190                &hash_types,
11191            ))
11192            .query(&progenitor_client::QueryParam::new("metadata", &metadata))
11193            .query(&progenitor_client::QueryParam::new(
11194                "noMimeType",
11195                &no_mime_type,
11196            ))
11197            .query(&progenitor_client::QueryParam::new(
11198                "noModTime",
11199                &no_mod_time,
11200            ))
11201            .query(&progenitor_client::QueryParam::new("opt", &opt))
11202            .query(&progenitor_client::QueryParam::new("recurse", &recurse))
11203            .query(&progenitor_client::QueryParam::new("remote", &remote))
11204            .query(&progenitor_client::QueryParam::new(
11205                "showEncrypted",
11206                &show_encrypted,
11207            ))
11208            .query(&progenitor_client::QueryParam::new("showHash", &show_hash))
11209            .query(&progenitor_client::QueryParam::new(
11210                "showOrigIDs",
11211                &show_orig_i_ds,
11212            ))
11213            .headers(header_map)
11214            .build()?;
11215        let info = OperationInfo {
11216            operation_id: "operations_list",
11217        };
11218        self.pre(&mut request, &info).await?;
11219        let result = self.exec(request, &info).await;
11220        self.post(&result, &info).await?;
11221        let response = result?;
11222        match response.status().as_u16() {
11223            200u16 => ResponseValue::from_response(response).await,
11224            400u16..=499u16 => Err(Error::ErrorResponse(
11225                ResponseValue::from_response(response).await?,
11226            )),
11227            500u16..=599u16 => Err(Error::ErrorResponse(
11228                ResponseValue::from_response(response).await?,
11229            )),
11230            _ => Err(Error::UnexpectedResponse(response)),
11231        }
11232    }
11233
11234    ///Stat an object
11235    ///
11236    ///Returns metadata for a single file or directory, mirroring `rclone
11237    /// lsjson` on one entry.
11238    ///
11239    ///Sends a `POST` request to `/operations/stat`
11240    ///
11241    ///Arguments:
11242    /// - `async_`: Run the command asynchronously. Returns a job id
11243    ///   immediately.
11244    /// - `group`: Assign the request to a custom stats group.
11245    /// - `fs`: Remote name or path that contains the item to inspect.
11246    /// - `opt`: Optional JSON object of listing flags, matching those accepted
11247    ///   by `operations/list`.
11248    /// - `remote`: Path to the file or directory within `fs` to describe.
11249    pub async fn operations_stat<'a>(
11250        &'a self,
11251        async_: Option<bool>,
11252        group: Option<&'a str>,
11253        fs: &'a str,
11254        opt: Option<&'a str>,
11255        remote: &'a str,
11256    ) -> Result<ResponseValue<types::OperationsStatResponse>, Error<types::RcError>> {
11257        let url = format!("{}/operations/stat", self.baseurl,);
11258        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11259        header_map.append(
11260            ::reqwest::header::HeaderName::from_static("api-version"),
11261            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11262        );
11263        #[allow(unused_mut)]
11264        let mut request = self
11265            .client
11266            .post(url)
11267            .header(
11268                ::reqwest::header::ACCEPT,
11269                ::reqwest::header::HeaderValue::from_static("application/json"),
11270            )
11271            .query(&progenitor_client::QueryParam::new("_async", &async_))
11272            .query(&progenitor_client::QueryParam::new("_group", &group))
11273            .query(&progenitor_client::QueryParam::new("fs", &fs))
11274            .query(&progenitor_client::QueryParam::new("opt", &opt))
11275            .query(&progenitor_client::QueryParam::new("remote", &remote))
11276            .headers(header_map)
11277            .build()?;
11278        let info = OperationInfo {
11279            operation_id: "operations_stat",
11280        };
11281        self.pre(&mut request, &info).await?;
11282        let result = self.exec(request, &info).await;
11283        self.post(&result, &info).await?;
11284        let response = result?;
11285        match response.status().as_u16() {
11286            200u16 => ResponseValue::from_response(response).await,
11287            400u16..=499u16 => Err(Error::ErrorResponse(
11288                ResponseValue::from_response(response).await?,
11289            )),
11290            500u16..=599u16 => Err(Error::ErrorResponse(
11291                ResponseValue::from_response(response).await?,
11292            )),
11293            _ => Err(Error::UnexpectedResponse(response)),
11294        }
11295    }
11296
11297    ///Get remote quota
11298    ///
11299    ///Returns storage quota and usage details for the remote, equivalent to
11300    /// `rclone about`.
11301    ///
11302    ///Sends a `POST` request to `/operations/about`
11303    ///
11304    ///Arguments:
11305    /// - `async_`: Run the command asynchronously. Returns a job id
11306    ///   immediately.
11307    /// - `group`: Assign the request to a custom stats group.
11308    /// - `fs`: Remote name or path to query for capacity information.
11309    pub async fn operations_about<'a>(
11310        &'a self,
11311        async_: Option<bool>,
11312        group: Option<&'a str>,
11313        fs: &'a str,
11314    ) -> Result<ResponseValue<types::OperationsAboutResponse>, Error<types::RcError>> {
11315        let url = format!("{}/operations/about", self.baseurl,);
11316        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11317        header_map.append(
11318            ::reqwest::header::HeaderName::from_static("api-version"),
11319            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11320        );
11321        #[allow(unused_mut)]
11322        let mut request = self
11323            .client
11324            .post(url)
11325            .header(
11326                ::reqwest::header::ACCEPT,
11327                ::reqwest::header::HeaderValue::from_static("application/json"),
11328            )
11329            .query(&progenitor_client::QueryParam::new("_async", &async_))
11330            .query(&progenitor_client::QueryParam::new("_group", &group))
11331            .query(&progenitor_client::QueryParam::new("fs", &fs))
11332            .headers(header_map)
11333            .build()?;
11334        let info = OperationInfo {
11335            operation_id: "operations_about",
11336        };
11337        self.pre(&mut request, &info).await?;
11338        let result = self.exec(request, &info).await;
11339        self.post(&result, &info).await?;
11340        let response = result?;
11341        match response.status().as_u16() {
11342            200u16 => ResponseValue::from_response(response).await,
11343            400u16..=499u16 => Err(Error::ErrorResponse(
11344                ResponseValue::from_response(response).await?,
11345            )),
11346            500u16..=599u16 => Err(Error::ErrorResponse(
11347                ResponseValue::from_response(response).await?,
11348            )),
11349            _ => Err(Error::UnexpectedResponse(response)),
11350        }
11351    }
11352
11353    ///Upload files via multipart
11354    ///
11355    ///Accepts multipart/form-data payloads and writes the uploaded files to
11356    /// the specified remote path.
11357    ///
11358    ///Sends a `POST` request to `/operations/uploadfile`
11359    ///
11360    ///Arguments:
11361    /// - `async_`: Run the command asynchronously. Returns a job id
11362    ///   immediately.
11363    /// - `group`: Assign the request to a custom stats group.
11364    /// - `fs`: Remote name or path where the uploaded file should be stored.
11365    /// - `remote`: Destination path within `fs` for the uploaded file.
11366    /// - `body`: Multipart form payload containing one or more files to upload.
11367    pub async fn operations_uploadfile<'a, B: Into<reqwest::Body>>(
11368        &'a self,
11369        async_: Option<bool>,
11370        group: Option<&'a str>,
11371        fs: &'a str,
11372        remote: &'a str,
11373        body: B,
11374    ) -> Result<
11375        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11376        Error<types::RcError>,
11377    > {
11378        let url = format!("{}/operations/uploadfile", self.baseurl,);
11379        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11380        header_map.append(
11381            ::reqwest::header::HeaderName::from_static("api-version"),
11382            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11383        );
11384        #[allow(unused_mut)]
11385        let mut request = self
11386            .client
11387            .post(url)
11388            .header(
11389                ::reqwest::header::ACCEPT,
11390                ::reqwest::header::HeaderValue::from_static("application/json"),
11391            )
11392            .header(
11393                ::reqwest::header::CONTENT_TYPE,
11394                ::reqwest::header::HeaderValue::from_static("application/octet-stream"),
11395            )
11396            .body(body)
11397            .query(&progenitor_client::QueryParam::new("_async", &async_))
11398            .query(&progenitor_client::QueryParam::new("_group", &group))
11399            .query(&progenitor_client::QueryParam::new("fs", &fs))
11400            .query(&progenitor_client::QueryParam::new("remote", &remote))
11401            .headers(header_map)
11402            .build()?;
11403        let info = OperationInfo {
11404            operation_id: "operations_uploadfile",
11405        };
11406        self.pre(&mut request, &info).await?;
11407        let result = self.exec(request, &info).await;
11408        self.post(&result, &info).await?;
11409        let response = result?;
11410        match response.status().as_u16() {
11411            200u16 => ResponseValue::from_response(response).await,
11412            400u16..=499u16 => Err(Error::ErrorResponse(
11413                ResponseValue::from_response(response).await?,
11414            )),
11415            500u16..=599u16 => Err(Error::ErrorResponse(
11416                ResponseValue::from_response(response).await?,
11417            )),
11418            _ => Err(Error::UnexpectedResponse(response)),
11419        }
11420    }
11421
11422    ///Purge directory
11423    ///
11424    ///Deletes a directory or container and all of its contents.
11425    ///
11426    ///Sends a `POST` request to `/operations/purge`
11427    ///
11428    ///Arguments:
11429    /// - `async_`: Run the command asynchronously. Returns a job id
11430    ///   immediately.
11431    /// - `config`: JSON encoded config overrides applied for this call only.
11432    /// - `filter`: JSON encoded filter overrides applied for this call only.
11433    /// - `group`: Assign the request to a custom stats group.
11434    /// - `fs`: Remote name or path from which to remove all contents.
11435    /// - `remote`: Path within `fs` whose contents should be purged.
11436    pub async fn operations_purge<'a>(
11437        &'a self,
11438        async_: Option<bool>,
11439        config: Option<&'a str>,
11440        filter: Option<&'a str>,
11441        group: Option<&'a str>,
11442        fs: &'a str,
11443        remote: &'a str,
11444    ) -> Result<
11445        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11446        Error<types::RcError>,
11447    > {
11448        let url = format!("{}/operations/purge", self.baseurl,);
11449        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11450        header_map.append(
11451            ::reqwest::header::HeaderName::from_static("api-version"),
11452            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11453        );
11454        #[allow(unused_mut)]
11455        let mut request = self
11456            .client
11457            .post(url)
11458            .header(
11459                ::reqwest::header::ACCEPT,
11460                ::reqwest::header::HeaderValue::from_static("application/json"),
11461            )
11462            .query(&progenitor_client::QueryParam::new("_async", &async_))
11463            .query(&progenitor_client::QueryParam::new("_config", &config))
11464            .query(&progenitor_client::QueryParam::new("_filter", &filter))
11465            .query(&progenitor_client::QueryParam::new("_group", &group))
11466            .query(&progenitor_client::QueryParam::new("fs", &fs))
11467            .query(&progenitor_client::QueryParam::new("remote", &remote))
11468            .headers(header_map)
11469            .build()?;
11470        let info = OperationInfo {
11471            operation_id: "operations_purge",
11472        };
11473        self.pre(&mut request, &info).await?;
11474        let result = self.exec(request, &info).await;
11475        self.post(&result, &info).await?;
11476        let response = result?;
11477        match response.status().as_u16() {
11478            200u16 => ResponseValue::from_response(response).await,
11479            400u16..=499u16 => Err(Error::ErrorResponse(
11480                ResponseValue::from_response(response).await?,
11481            )),
11482            500u16..=599u16 => Err(Error::ErrorResponse(
11483                ResponseValue::from_response(response).await?,
11484            )),
11485            _ => Err(Error::UnexpectedResponse(response)),
11486        }
11487    }
11488
11489    ///Create directory
11490    ///
11491    ///Creates the target directory or container if it does not exist.
11492    ///
11493    ///Sends a `POST` request to `/operations/mkdir`
11494    ///
11495    ///Arguments:
11496    /// - `async_`: Run the command asynchronously. Returns a job id
11497    ///   immediately.
11498    /// - `group`: Assign the request to a custom stats group.
11499    /// - `fs`: Remote name or path in which to create a directory.
11500    /// - `remote`: Directory path within `fs` to create.
11501    pub async fn operations_mkdir<'a>(
11502        &'a self,
11503        async_: Option<bool>,
11504        group: Option<&'a str>,
11505        fs: &'a str,
11506        remote: &'a str,
11507    ) -> Result<
11508        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11509        Error<types::RcError>,
11510    > {
11511        let url = format!("{}/operations/mkdir", self.baseurl,);
11512        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11513        header_map.append(
11514            ::reqwest::header::HeaderName::from_static("api-version"),
11515            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11516        );
11517        #[allow(unused_mut)]
11518        let mut request = self
11519            .client
11520            .post(url)
11521            .header(
11522                ::reqwest::header::ACCEPT,
11523                ::reqwest::header::HeaderValue::from_static("application/json"),
11524            )
11525            .query(&progenitor_client::QueryParam::new("_async", &async_))
11526            .query(&progenitor_client::QueryParam::new("_group", &group))
11527            .query(&progenitor_client::QueryParam::new("fs", &fs))
11528            .query(&progenitor_client::QueryParam::new("remote", &remote))
11529            .headers(header_map)
11530            .build()?;
11531        let info = OperationInfo {
11532            operation_id: "operations_mkdir",
11533        };
11534        self.pre(&mut request, &info).await?;
11535        let result = self.exec(request, &info).await;
11536        self.post(&result, &info).await?;
11537        let response = result?;
11538        match response.status().as_u16() {
11539            200u16 => ResponseValue::from_response(response).await,
11540            400u16..=499u16 => Err(Error::ErrorResponse(
11541                ResponseValue::from_response(response).await?,
11542            )),
11543            500u16..=599u16 => Err(Error::ErrorResponse(
11544                ResponseValue::from_response(response).await?,
11545            )),
11546            _ => Err(Error::UnexpectedResponse(response)),
11547        }
11548    }
11549
11550    ///Remove empty directory
11551    ///
11552    ///Deletes an empty directory or container.
11553    ///
11554    ///Sends a `POST` request to `/operations/rmdir`
11555    ///
11556    ///Arguments:
11557    /// - `async_`: Run the command asynchronously. Returns a job id
11558    ///   immediately.
11559    /// - `group`: Assign the request to a custom stats group.
11560    /// - `fs`: Remote name or path containing the directory to remove.
11561    /// - `remote`: Directory path within `fs` to delete.
11562    pub async fn operations_rmdir<'a>(
11563        &'a self,
11564        async_: Option<bool>,
11565        group: Option<&'a str>,
11566        fs: &'a str,
11567        remote: &'a str,
11568    ) -> Result<
11569        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11570        Error<types::RcError>,
11571    > {
11572        let url = format!("{}/operations/rmdir", self.baseurl,);
11573        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11574        header_map.append(
11575            ::reqwest::header::HeaderName::from_static("api-version"),
11576            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11577        );
11578        #[allow(unused_mut)]
11579        let mut request = self
11580            .client
11581            .post(url)
11582            .header(
11583                ::reqwest::header::ACCEPT,
11584                ::reqwest::header::HeaderValue::from_static("application/json"),
11585            )
11586            .query(&progenitor_client::QueryParam::new("_async", &async_))
11587            .query(&progenitor_client::QueryParam::new("_group", &group))
11588            .query(&progenitor_client::QueryParam::new("fs", &fs))
11589            .query(&progenitor_client::QueryParam::new("remote", &remote))
11590            .headers(header_map)
11591            .build()?;
11592        let info = OperationInfo {
11593            operation_id: "operations_rmdir",
11594        };
11595        self.pre(&mut request, &info).await?;
11596        let result = self.exec(request, &info).await;
11597        self.post(&result, &info).await?;
11598        let response = result?;
11599        match response.status().as_u16() {
11600            200u16 => ResponseValue::from_response(response).await,
11601            400u16..=499u16 => Err(Error::ErrorResponse(
11602                ResponseValue::from_response(response).await?,
11603            )),
11604            500u16..=599u16 => Err(Error::ErrorResponse(
11605                ResponseValue::from_response(response).await?,
11606            )),
11607            _ => Err(Error::UnexpectedResponse(response)),
11608        }
11609    }
11610
11611    ///Compare source and destination
11612    ///
11613    ///Compares source and destination trees, reporting matches, differences,
11614    /// and missing files.
11615    ///
11616    ///Sends a `POST` request to `/operations/check`
11617    ///
11618    ///Arguments:
11619    /// - `async_`: Run the command asynchronously. Returns a job id
11620    ///   immediately.
11621    /// - `group`: Assign the request to a custom stats group.
11622    /// - `check_file_fs`: Remote containing the checksum SUM file when using
11623    ///   `checkFileHash`.
11624    /// - `check_file_hash`: Hash name to expect in the supplied SUM file, such
11625    ///   as `md5`.
11626    /// - `check_file_remote`: Path within `checkFileFs` to the checksum SUM
11627    ///   file.
11628    /// - `combined`: Set to true to include a combined summary report in the
11629    ///   response.
11630    /// - `differ`: Set to true to include differing files in the report.
11631    /// - `download`: Set to true to read file contents during comparison
11632    ///   instead of relying on hashes.
11633    /// - `dst_fs`: Destination remote name or path that should match the
11634    ///   source.
11635    /// - `error`: Set to true to include entries that encountered errors.
11636    /// - `match_`: Set to true to include matching files in the report.
11637    /// - `missing_on_dst`: Set to true to report files missing from the
11638    ///   destination.
11639    /// - `missing_on_src`: Set to true to report files missing from the source.
11640    /// - `one_way`: Set to true to only ensure that source files exist on the
11641    ///   destination.
11642    /// - `src_fs`: Source remote name or path to verify, e.g. `drive:`.
11643    pub async fn operations_check<'a>(
11644        &'a self,
11645        async_: Option<bool>,
11646        group: Option<&'a str>,
11647        check_file_fs: Option<&'a str>,
11648        check_file_hash: Option<&'a str>,
11649        check_file_remote: Option<&'a str>,
11650        combined: Option<bool>,
11651        differ: Option<bool>,
11652        download: Option<bool>,
11653        dst_fs: &'a str,
11654        error: Option<bool>,
11655        match_: Option<bool>,
11656        missing_on_dst: Option<bool>,
11657        missing_on_src: Option<bool>,
11658        one_way: Option<bool>,
11659        src_fs: &'a str,
11660    ) -> Result<ResponseValue<types::OperationsCheckResponse>, Error<types::RcError>> {
11661        let url = format!("{}/operations/check", self.baseurl,);
11662        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11663        header_map.append(
11664            ::reqwest::header::HeaderName::from_static("api-version"),
11665            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11666        );
11667        #[allow(unused_mut)]
11668        let mut request = self
11669            .client
11670            .post(url)
11671            .header(
11672                ::reqwest::header::ACCEPT,
11673                ::reqwest::header::HeaderValue::from_static("application/json"),
11674            )
11675            .query(&progenitor_client::QueryParam::new("_async", &async_))
11676            .query(&progenitor_client::QueryParam::new("_group", &group))
11677            .query(&progenitor_client::QueryParam::new(
11678                "checkFileFs",
11679                &check_file_fs,
11680            ))
11681            .query(&progenitor_client::QueryParam::new(
11682                "checkFileHash",
11683                &check_file_hash,
11684            ))
11685            .query(&progenitor_client::QueryParam::new(
11686                "checkFileRemote",
11687                &check_file_remote,
11688            ))
11689            .query(&progenitor_client::QueryParam::new("combined", &combined))
11690            .query(&progenitor_client::QueryParam::new("differ", &differ))
11691            .query(&progenitor_client::QueryParam::new("download", &download))
11692            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
11693            .query(&progenitor_client::QueryParam::new("error", &error))
11694            .query(&progenitor_client::QueryParam::new("match", &match_))
11695            .query(&progenitor_client::QueryParam::new(
11696                "missingOnDst",
11697                &missing_on_dst,
11698            ))
11699            .query(&progenitor_client::QueryParam::new(
11700                "missingOnSrc",
11701                &missing_on_src,
11702            ))
11703            .query(&progenitor_client::QueryParam::new("oneWay", &one_way))
11704            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
11705            .headers(header_map)
11706            .build()?;
11707        let info = OperationInfo {
11708            operation_id: "operations_check",
11709        };
11710        self.pre(&mut request, &info).await?;
11711        let result = self.exec(request, &info).await;
11712        self.post(&result, &info).await?;
11713        let response = result?;
11714        match response.status().as_u16() {
11715            200u16 => ResponseValue::from_response(response).await,
11716            400u16..=499u16 => Err(Error::ErrorResponse(
11717                ResponseValue::from_response(response).await?,
11718            )),
11719            500u16..=599u16 => Err(Error::ErrorResponse(
11720                ResponseValue::from_response(response).await?,
11721            )),
11722            _ => Err(Error::UnexpectedResponse(response)),
11723        }
11724    }
11725
11726    ///Sync source to destination
11727    ///
11728    ///Synchronises a source remote to a destination remote, making the
11729    /// destination match the source.
11730    ///
11731    ///Sends a `POST` request to `/sync/sync`
11732    ///
11733    ///Arguments:
11734    /// - `async_`: Run the command asynchronously. Returns a job id
11735    ///   immediately.
11736    /// - `config`: JSON encoded config overrides applied for this call only.
11737    /// - `filter`: JSON encoded filter overrides applied for this call only.
11738    /// - `group`: Assign the request to a custom stats group.
11739    /// - `create_empty_src_dirs`: Set to true to create empty source
11740    ///   directories on the destination.
11741    /// - `dst_fs`: Destination remote path to sync to, e.g. `drive:dst`.
11742    /// - `src_fs`: Source remote path to sync from, e.g. `drive:src`.
11743    pub async fn sync_sync<'a>(
11744        &'a self,
11745        async_: Option<bool>,
11746        config: Option<&'a str>,
11747        filter: Option<&'a str>,
11748        group: Option<&'a str>,
11749        create_empty_src_dirs: Option<bool>,
11750        dst_fs: &'a str,
11751        src_fs: &'a str,
11752    ) -> Result<
11753        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11754        Error<types::RcError>,
11755    > {
11756        let url = format!("{}/sync/sync", self.baseurl,);
11757        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11758        header_map.append(
11759            ::reqwest::header::HeaderName::from_static("api-version"),
11760            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11761        );
11762        #[allow(unused_mut)]
11763        let mut request = self
11764            .client
11765            .post(url)
11766            .header(
11767                ::reqwest::header::ACCEPT,
11768                ::reqwest::header::HeaderValue::from_static("application/json"),
11769            )
11770            .query(&progenitor_client::QueryParam::new("_async", &async_))
11771            .query(&progenitor_client::QueryParam::new("_config", &config))
11772            .query(&progenitor_client::QueryParam::new("_filter", &filter))
11773            .query(&progenitor_client::QueryParam::new("_group", &group))
11774            .query(&progenitor_client::QueryParam::new(
11775                "createEmptySrcDirs",
11776                &create_empty_src_dirs,
11777            ))
11778            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
11779            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
11780            .headers(header_map)
11781            .build()?;
11782        let info = OperationInfo {
11783            operation_id: "sync_sync",
11784        };
11785        self.pre(&mut request, &info).await?;
11786        let result = self.exec(request, &info).await;
11787        self.post(&result, &info).await?;
11788        let response = result?;
11789        match response.status().as_u16() {
11790            200u16 => ResponseValue::from_response(response).await,
11791            400u16..=499u16 => Err(Error::ErrorResponse(
11792                ResponseValue::from_response(response).await?,
11793            )),
11794            500u16..=599u16 => Err(Error::ErrorResponse(
11795                ResponseValue::from_response(response).await?,
11796            )),
11797            _ => Err(Error::UnexpectedResponse(response)),
11798        }
11799    }
11800
11801    ///Copy source to destination
11802    ///
11803    ///Copies objects from a source remote to a destination remote without
11804    /// deleting destination files.
11805    ///
11806    ///Sends a `POST` request to `/sync/copy`
11807    ///
11808    ///Arguments:
11809    /// - `async_`: Run the command asynchronously. Returns a job id
11810    ///   immediately.
11811    /// - `config`: JSON encoded config overrides applied for this call only.
11812    /// - `filter`: JSON encoded filter overrides applied for this call only.
11813    /// - `group`: Assign the request to a custom stats group.
11814    /// - `create_empty_src_dirs`: Set to true to replicate empty source
11815    ///   directories on the destination.
11816    /// - `dst_fs`: Destination remote path to copy to.
11817    /// - `src_fs`: Source remote path to copy from.
11818    pub async fn sync_copy<'a>(
11819        &'a self,
11820        async_: Option<bool>,
11821        config: Option<&'a str>,
11822        filter: Option<&'a str>,
11823        group: Option<&'a str>,
11824        create_empty_src_dirs: Option<bool>,
11825        dst_fs: &'a str,
11826        src_fs: &'a str,
11827    ) -> Result<
11828        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11829        Error<types::RcError>,
11830    > {
11831        let url = format!("{}/sync/copy", self.baseurl,);
11832        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11833        header_map.append(
11834            ::reqwest::header::HeaderName::from_static("api-version"),
11835            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11836        );
11837        #[allow(unused_mut)]
11838        let mut request = self
11839            .client
11840            .post(url)
11841            .header(
11842                ::reqwest::header::ACCEPT,
11843                ::reqwest::header::HeaderValue::from_static("application/json"),
11844            )
11845            .query(&progenitor_client::QueryParam::new("_async", &async_))
11846            .query(&progenitor_client::QueryParam::new("_config", &config))
11847            .query(&progenitor_client::QueryParam::new("_filter", &filter))
11848            .query(&progenitor_client::QueryParam::new("_group", &group))
11849            .query(&progenitor_client::QueryParam::new(
11850                "createEmptySrcDirs",
11851                &create_empty_src_dirs,
11852            ))
11853            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
11854            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
11855            .headers(header_map)
11856            .build()?;
11857        let info = OperationInfo {
11858            operation_id: "sync_copy",
11859        };
11860        self.pre(&mut request, &info).await?;
11861        let result = self.exec(request, &info).await;
11862        self.post(&result, &info).await?;
11863        let response = result?;
11864        match response.status().as_u16() {
11865            200u16 => ResponseValue::from_response(response).await,
11866            400u16..=499u16 => Err(Error::ErrorResponse(
11867                ResponseValue::from_response(response).await?,
11868            )),
11869            500u16..=599u16 => Err(Error::ErrorResponse(
11870                ResponseValue::from_response(response).await?,
11871            )),
11872            _ => Err(Error::UnexpectedResponse(response)),
11873        }
11874    }
11875
11876    ///Move source to destination
11877    ///
11878    ///Moves objects from a source remote to a destination remote, optionally
11879    /// cleaning up empty directories.
11880    ///
11881    ///Sends a `POST` request to `/sync/move`
11882    ///
11883    ///Arguments:
11884    /// - `async_`: Run the command asynchronously. Returns a job id
11885    ///   immediately.
11886    /// - `config`: JSON encoded config overrides applied for this call only.
11887    /// - `filter`: JSON encoded filter overrides applied for this call only.
11888    /// - `group`: Assign the request to a custom stats group.
11889    /// - `create_empty_src_dirs`: Set to true to create empty source
11890    ///   directories on the destination.
11891    /// - `delete_empty_src_dirs`: Set to true to delete empty directories from
11892    ///   the source after the move completes.
11893    /// - `dst_fs`: Destination remote path that will receive moved files.
11894    /// - `src_fs`: Source remote path whose contents will be moved.
11895    pub async fn sync_move<'a>(
11896        &'a self,
11897        async_: Option<bool>,
11898        config: Option<&'a str>,
11899        filter: Option<&'a str>,
11900        group: Option<&'a str>,
11901        create_empty_src_dirs: Option<bool>,
11902        delete_empty_src_dirs: Option<bool>,
11903        dst_fs: &'a str,
11904        src_fs: &'a str,
11905    ) -> Result<
11906        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
11907        Error<types::RcError>,
11908    > {
11909        let url = format!("{}/sync/move", self.baseurl,);
11910        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
11911        header_map.append(
11912            ::reqwest::header::HeaderName::from_static("api-version"),
11913            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
11914        );
11915        #[allow(unused_mut)]
11916        let mut request = self
11917            .client
11918            .post(url)
11919            .header(
11920                ::reqwest::header::ACCEPT,
11921                ::reqwest::header::HeaderValue::from_static("application/json"),
11922            )
11923            .query(&progenitor_client::QueryParam::new("_async", &async_))
11924            .query(&progenitor_client::QueryParam::new("_config", &config))
11925            .query(&progenitor_client::QueryParam::new("_filter", &filter))
11926            .query(&progenitor_client::QueryParam::new("_group", &group))
11927            .query(&progenitor_client::QueryParam::new(
11928                "createEmptySrcDirs",
11929                &create_empty_src_dirs,
11930            ))
11931            .query(&progenitor_client::QueryParam::new(
11932                "deleteEmptySrcDirs",
11933                &delete_empty_src_dirs,
11934            ))
11935            .query(&progenitor_client::QueryParam::new("dstFs", &dst_fs))
11936            .query(&progenitor_client::QueryParam::new("srcFs", &src_fs))
11937            .headers(header_map)
11938            .build()?;
11939        let info = OperationInfo {
11940            operation_id: "sync_move",
11941        };
11942        self.pre(&mut request, &info).await?;
11943        let result = self.exec(request, &info).await;
11944        self.post(&result, &info).await?;
11945        let response = result?;
11946        match response.status().as_u16() {
11947            200u16 => ResponseValue::from_response(response).await,
11948            400u16..=499u16 => Err(Error::ErrorResponse(
11949                ResponseValue::from_response(response).await?,
11950            )),
11951            500u16..=599u16 => Err(Error::ErrorResponse(
11952                ResponseValue::from_response(response).await?,
11953            )),
11954            _ => Err(Error::UnexpectedResponse(response)),
11955        }
11956    }
11957
11958    ///Bidirectional sync
11959    ///
11960    ///Performs a bidirectional synchronisation between two paths, supporting
11961    /// safety checks and recovery options.
11962    ///
11963    ///Sends a `POST` request to `/sync/bisync`
11964    ///
11965    ///Arguments:
11966    /// - `async_`: Run the command asynchronously. Returns a job id
11967    ///   immediately.
11968    /// - `config`: JSON encoded config overrides applied for this call only.
11969    /// - `filter`: JSON encoded filter overrides applied for this call only.
11970    /// - `group`: Assign the request to a custom stats group.
11971    /// - `backupdir1`: Backup directory on the first remote for changed files.
11972    /// - `backupdir2`: Backup directory on the second remote for changed files.
11973    /// - `check_access`: Set to true to abort if `RCLONE_TEST` files are
11974    ///   missing on either side.
11975    /// - `check_filename`: Override the access-check sentinel filename;
11976    ///   defaults to `RCLONE_TEST`.
11977    /// - `check_sync`: Controls final listing comparison; leave true for normal
11978    ///   verification or set false to skip.
11979    /// - `create_empty_src_dirs`: Set to true to mirror empty directories
11980    ///   between the two paths.
11981    /// - `dry_run`: Set to true to simulate the bisync run without making
11982    ///   changes.
11983    /// - `filters_file`: Path to an rclone filters file applied to both paths.
11984    /// - `force`: Set to true to bypass the `maxDelete` safety check.
11985    /// - `ignore_listing_checksum`: Set to true to ignore checksum differences
11986    ///   when comparing listings.
11987    /// - `max_delete`: Abort the run if deletions exceed this percentage
11988    ///   (default 50).
11989    /// - `no_cleanup`: Set to true to keep bisync working files after
11990    ///   completion.
11991    /// - `path1`: First remote directory, e.g. `drive:path1`.
11992    /// - `path2`: Second remote directory, e.g. `drive:path2`.
11993    /// - `remove_empty_dirs`: Set to true to remove empty directories during
11994    ///   cleanup.
11995    /// - `resilient`: Set to true to allow retrying after certain recoverable
11996    ///   errors.
11997    /// - `resync`: Set to true to perform a one-time resync, rebuilding bisync
11998    ///   history.
11999    /// - `workdir`: Directory path used to store bisync working files.
12000    pub async fn sync_bisync<'a>(
12001        &'a self,
12002        async_: Option<bool>,
12003        config: Option<&'a str>,
12004        filter: Option<&'a str>,
12005        group: Option<&'a str>,
12006        backupdir1: Option<&'a str>,
12007        backupdir2: Option<&'a str>,
12008        check_access: Option<bool>,
12009        check_filename: Option<&'a str>,
12010        check_sync: Option<bool>,
12011        create_empty_src_dirs: Option<bool>,
12012        dry_run: Option<bool>,
12013        filters_file: Option<&'a str>,
12014        force: Option<bool>,
12015        ignore_listing_checksum: Option<bool>,
12016        max_delete: Option<f64>,
12017        no_cleanup: Option<bool>,
12018        path1: &'a str,
12019        path2: &'a str,
12020        remove_empty_dirs: Option<bool>,
12021        resilient: Option<bool>,
12022        resync: Option<bool>,
12023        workdir: Option<&'a str>,
12024    ) -> Result<
12025        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12026        Error<types::RcError>,
12027    > {
12028        let url = format!("{}/sync/bisync", self.baseurl,);
12029        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12030        header_map.append(
12031            ::reqwest::header::HeaderName::from_static("api-version"),
12032            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12033        );
12034        #[allow(unused_mut)]
12035        let mut request = self
12036            .client
12037            .post(url)
12038            .header(
12039                ::reqwest::header::ACCEPT,
12040                ::reqwest::header::HeaderValue::from_static("application/json"),
12041            )
12042            .query(&progenitor_client::QueryParam::new("_async", &async_))
12043            .query(&progenitor_client::QueryParam::new("_config", &config))
12044            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12045            .query(&progenitor_client::QueryParam::new("_group", &group))
12046            .query(&progenitor_client::QueryParam::new(
12047                "backupdir1",
12048                &backupdir1,
12049            ))
12050            .query(&progenitor_client::QueryParam::new(
12051                "backupdir2",
12052                &backupdir2,
12053            ))
12054            .query(&progenitor_client::QueryParam::new(
12055                "checkAccess",
12056                &check_access,
12057            ))
12058            .query(&progenitor_client::QueryParam::new(
12059                "checkFilename",
12060                &check_filename,
12061            ))
12062            .query(&progenitor_client::QueryParam::new(
12063                "checkSync",
12064                &check_sync,
12065            ))
12066            .query(&progenitor_client::QueryParam::new(
12067                "createEmptySrcDirs",
12068                &create_empty_src_dirs,
12069            ))
12070            .query(&progenitor_client::QueryParam::new("dryRun", &dry_run))
12071            .query(&progenitor_client::QueryParam::new(
12072                "filtersFile",
12073                &filters_file,
12074            ))
12075            .query(&progenitor_client::QueryParam::new("force", &force))
12076            .query(&progenitor_client::QueryParam::new(
12077                "ignoreListingChecksum",
12078                &ignore_listing_checksum,
12079            ))
12080            .query(&progenitor_client::QueryParam::new(
12081                "maxDelete",
12082                &max_delete,
12083            ))
12084            .query(&progenitor_client::QueryParam::new(
12085                "noCleanup",
12086                &no_cleanup,
12087            ))
12088            .query(&progenitor_client::QueryParam::new("path1", &path1))
12089            .query(&progenitor_client::QueryParam::new("path2", &path2))
12090            .query(&progenitor_client::QueryParam::new(
12091                "removeEmptyDirs",
12092                &remove_empty_dirs,
12093            ))
12094            .query(&progenitor_client::QueryParam::new("resilient", &resilient))
12095            .query(&progenitor_client::QueryParam::new("resync", &resync))
12096            .query(&progenitor_client::QueryParam::new("workdir", &workdir))
12097            .headers(header_map)
12098            .build()?;
12099        let info = OperationInfo {
12100            operation_id: "sync_bisync",
12101        };
12102        self.pre(&mut request, &info).await?;
12103        let result = self.exec(request, &info).await;
12104        self.post(&result, &info).await?;
12105        let response = result?;
12106        match response.status().as_u16() {
12107            200u16 => ResponseValue::from_response(response).await,
12108            400u16..=499u16 => Err(Error::ErrorResponse(
12109                ResponseValue::from_response(response).await?,
12110            )),
12111            500u16..=599u16 => Err(Error::ErrorResponse(
12112                ResponseValue::from_response(response).await?,
12113            )),
12114            _ => Err(Error::UnexpectedResponse(response)),
12115        }
12116    }
12117
12118    ///List option blocks
12119    ///
12120    ///Returns the names of option blocks that can be queried or updated.
12121    ///
12122    ///Sends a `POST` request to `/options/blocks`
12123    ///
12124    ///Arguments:
12125    /// - `async_`: Run the command asynchronously. Returns a job id
12126    ///   immediately.
12127    /// - `group`: Assign the request to a custom stats group.
12128    pub async fn options_blocks<'a>(
12129        &'a self,
12130        async_: Option<bool>,
12131        group: Option<&'a str>,
12132    ) -> Result<ResponseValue<types::OptionsBlocksResponse>, Error<types::RcError>> {
12133        let url = format!("{}/options/blocks", self.baseurl,);
12134        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12135        header_map.append(
12136            ::reqwest::header::HeaderName::from_static("api-version"),
12137            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12138        );
12139        #[allow(unused_mut)]
12140        let mut request = self
12141            .client
12142            .post(url)
12143            .header(
12144                ::reqwest::header::ACCEPT,
12145                ::reqwest::header::HeaderValue::from_static("application/json"),
12146            )
12147            .query(&progenitor_client::QueryParam::new("_async", &async_))
12148            .query(&progenitor_client::QueryParam::new("_group", &group))
12149            .headers(header_map)
12150            .build()?;
12151        let info = OperationInfo {
12152            operation_id: "options_blocks",
12153        };
12154        self.pre(&mut request, &info).await?;
12155        let result = self.exec(request, &info).await;
12156        self.post(&result, &info).await?;
12157        let response = result?;
12158        match response.status().as_u16() {
12159            200u16 => ResponseValue::from_response(response).await,
12160            400u16..=499u16 => Err(Error::ErrorResponse(
12161                ResponseValue::from_response(response).await?,
12162            )),
12163            500u16..=599u16 => Err(Error::ErrorResponse(
12164                ResponseValue::from_response(response).await?,
12165            )),
12166            _ => Err(Error::UnexpectedResponse(response)),
12167        }
12168    }
12169
12170    ///Get option values
12171    ///
12172    ///Returns the current global option values, optionally filtered by block.
12173    ///
12174    ///Sends a `POST` request to `/options/get`
12175    ///
12176    ///Arguments:
12177    /// - `async_`: Run the command asynchronously. Returns a job id
12178    ///   immediately.
12179    /// - `group`: Assign the request to a custom stats group.
12180    /// - `blocks`: Optional comma-separated list of option block names to
12181    ///   return.
12182    pub async fn options_get<'a>(
12183        &'a self,
12184        async_: Option<bool>,
12185        group: Option<&'a str>,
12186        blocks: Option<&'a str>,
12187    ) -> Result<ResponseValue<types::OptionsGetResponse>, Error<types::RcError>> {
12188        let url = format!("{}/options/get", self.baseurl,);
12189        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12190        header_map.append(
12191            ::reqwest::header::HeaderName::from_static("api-version"),
12192            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12193        );
12194        #[allow(unused_mut)]
12195        let mut request = self
12196            .client
12197            .post(url)
12198            .header(
12199                ::reqwest::header::ACCEPT,
12200                ::reqwest::header::HeaderValue::from_static("application/json"),
12201            )
12202            .query(&progenitor_client::QueryParam::new("_async", &async_))
12203            .query(&progenitor_client::QueryParam::new("_group", &group))
12204            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12205            .headers(header_map)
12206            .build()?;
12207        let info = OperationInfo {
12208            operation_id: "options_get",
12209        };
12210        self.pre(&mut request, &info).await?;
12211        let result = self.exec(request, &info).await;
12212        self.post(&result, &info).await?;
12213        let response = result?;
12214        match response.status().as_u16() {
12215            200u16 => ResponseValue::from_response(response).await,
12216            400u16..=499u16 => Err(Error::ErrorResponse(
12217                ResponseValue::from_response(response).await?,
12218            )),
12219            500u16..=599u16 => Err(Error::ErrorResponse(
12220                ResponseValue::from_response(response).await?,
12221            )),
12222            _ => Err(Error::UnexpectedResponse(response)),
12223        }
12224    }
12225
12226    ///Describe options
12227    ///
12228    ///Returns metadata for options, including help text and defaults, grouped
12229    /// by block.
12230    ///
12231    ///Sends a `POST` request to `/options/info`
12232    ///
12233    ///Arguments:
12234    /// - `async_`: Run the command asynchronously. Returns a job id
12235    ///   immediately.
12236    /// - `group`: Assign the request to a custom stats group.
12237    /// - `blocks`: Optional comma-separated list of option block names to
12238    ///   describe.
12239    pub async fn options_info<'a>(
12240        &'a self,
12241        async_: Option<bool>,
12242        group: Option<&'a str>,
12243        blocks: Option<&'a str>,
12244    ) -> Result<ResponseValue<types::OptionsInfoResponse>, Error<types::RcError>> {
12245        let url = format!("{}/options/info", self.baseurl,);
12246        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12247        header_map.append(
12248            ::reqwest::header::HeaderName::from_static("api-version"),
12249            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12250        );
12251        #[allow(unused_mut)]
12252        let mut request = self
12253            .client
12254            .post(url)
12255            .header(
12256                ::reqwest::header::ACCEPT,
12257                ::reqwest::header::HeaderValue::from_static("application/json"),
12258            )
12259            .query(&progenitor_client::QueryParam::new("_async", &async_))
12260            .query(&progenitor_client::QueryParam::new("_group", &group))
12261            .query(&progenitor_client::QueryParam::new("blocks", &blocks))
12262            .headers(header_map)
12263            .build()?;
12264        let info = OperationInfo {
12265            operation_id: "options_info",
12266        };
12267        self.pre(&mut request, &info).await?;
12268        let result = self.exec(request, &info).await;
12269        self.post(&result, &info).await?;
12270        let response = result?;
12271        match response.status().as_u16() {
12272            200u16 => ResponseValue::from_response(response).await,
12273            400u16..=499u16 => Err(Error::ErrorResponse(
12274                ResponseValue::from_response(response).await?,
12275            )),
12276            500u16..=599u16 => Err(Error::ErrorResponse(
12277                ResponseValue::from_response(response).await?,
12278            )),
12279            _ => Err(Error::UnexpectedResponse(response)),
12280        }
12281    }
12282
12283    ///Set option values
12284    ///
12285    ///Sets temporary option overrides for the running process by supplying
12286    /// key/value pairs grouped under option block names. Provide one or more
12287    /// query parameters whose names match the blocks you want to modify (for
12288    /// example `main`, `rc`, `http`). Each block parameter carries an object of
12289    /// option overrides.
12290    ///
12291    ///
12292    ///Sends a `POST` request to `/options/set`
12293    ///
12294    ///Arguments:
12295    /// - `async_`: Run the command asynchronously. Returns a job id
12296    ///   immediately.
12297    /// - `group`: Assign the request to a custom stats group.
12298    /// - `dlna`: Overrides for the `dlna` option block.
12299    /// - `filter`: Overrides for the `filter` option block.
12300    /// - `ftp`: Overrides for the `ftp` option block.
12301    /// - `http`: Overrides for the `http` option block.
12302    /// - `log`: Overrides for the `log` option block.
12303    /// - `main`: Overrides for the `main` option block.
12304    /// - `mount`: Overrides for the `mount` option block.
12305    /// - `nfs`: Overrides for the `nfs` option block.
12306    /// - `proxy`: Overrides for the `proxy` option block.
12307    /// - `rc`: Overrides for the `rc` option block.
12308    /// - `restic`: Overrides for the `restic` option block.
12309    /// - `s3`: Overrides for the `s3` option block.
12310    /// - `sftp`: Overrides for the `sftp` option block.
12311    /// - `vfs`: Overrides for the `vfs` option block.
12312    /// - `webdav`: Overrides for the `webdav` option block.
12313    pub async fn options_set<'a>(
12314        &'a self,
12315        async_: Option<bool>,
12316        group: Option<&'a str>,
12317        dlna: Option<
12318            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetDlnaValue>,
12319        >,
12320        filter: Option<
12321            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFilterValue>,
12322        >,
12323        ftp: Option<
12324            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetFtpValue>,
12325        >,
12326        http: Option<
12327            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetHttpValue>,
12328        >,
12329        log: Option<
12330            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetLogValue>,
12331        >,
12332        main: Option<
12333            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMainValue>,
12334        >,
12335        mount: Option<
12336            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetMountValue>,
12337        >,
12338        nfs: Option<
12339            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetNfsValue>,
12340        >,
12341        proxy: Option<
12342            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetProxyValue>,
12343        >,
12344        rc: Option<
12345            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetRcValue>,
12346        >,
12347        restic: Option<
12348            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetResticValue>,
12349        >,
12350        s3: Option<
12351            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetS3Value>,
12352        >,
12353        sftp: Option<
12354            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetSftpValue>,
12355        >,
12356        vfs: Option<
12357            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetVfsValue>,
12358        >,
12359        webdav: Option<
12360            &'a ::std::collections::HashMap<::std::string::String, types::OptionsSetWebdavValue>,
12361        >,
12362    ) -> Result<
12363        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12364        Error<types::RcError>,
12365    > {
12366        let url = format!("{}/options/set", self.baseurl,);
12367        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12368        header_map.append(
12369            ::reqwest::header::HeaderName::from_static("api-version"),
12370            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12371        );
12372        #[allow(unused_mut)]
12373        let mut request = self
12374            .client
12375            .post(url)
12376            .header(
12377                ::reqwest::header::ACCEPT,
12378                ::reqwest::header::HeaderValue::from_static("application/json"),
12379            )
12380            .query(&progenitor_client::QueryParam::new("_async", &async_))
12381            .query(&progenitor_client::QueryParam::new("_group", &group))
12382            .query(&progenitor_client::QueryParam::new("dlna", &dlna))
12383            .query(&progenitor_client::QueryParam::new("filter", &filter))
12384            .query(&progenitor_client::QueryParam::new("ftp", &ftp))
12385            .query(&progenitor_client::QueryParam::new("http", &http))
12386            .query(&progenitor_client::QueryParam::new("log", &log))
12387            .query(&progenitor_client::QueryParam::new("main", &main))
12388            .query(&progenitor_client::QueryParam::new("mount", &mount))
12389            .query(&progenitor_client::QueryParam::new("nfs", &nfs))
12390            .query(&progenitor_client::QueryParam::new("proxy", &proxy))
12391            .query(&progenitor_client::QueryParam::new("rc", &rc))
12392            .query(&progenitor_client::QueryParam::new("restic", &restic))
12393            .query(&progenitor_client::QueryParam::new("s3", &s3))
12394            .query(&progenitor_client::QueryParam::new("sftp", &sftp))
12395            .query(&progenitor_client::QueryParam::new("vfs", &vfs))
12396            .query(&progenitor_client::QueryParam::new("webdav", &webdav))
12397            .headers(header_map)
12398            .build()?;
12399        let info = OperationInfo {
12400            operation_id: "options_set",
12401        };
12402        self.pre(&mut request, &info).await?;
12403        let result = self.exec(request, &info).await;
12404        self.post(&result, &info).await?;
12405        let response = result?;
12406        match response.status().as_u16() {
12407            200u16 => ResponseValue::from_response(response).await,
12408            400u16..=499u16 => Err(Error::ErrorResponse(
12409                ResponseValue::from_response(response).await?,
12410            )),
12411            500u16..=599u16 => Err(Error::ErrorResponse(
12412                ResponseValue::from_response(response).await?,
12413            )),
12414            _ => Err(Error::UnexpectedResponse(response)),
12415        }
12416    }
12417
12418    ///Show effective options
12419    ///
12420    ///Returns the current effective options for this request, including
12421    /// `_config` and `_filter` overrides.
12422    ///
12423    ///Sends a `POST` request to `/options/local`
12424    ///
12425    ///Arguments:
12426    /// - `async_`: Run the command asynchronously. Returns a job id
12427    ///   immediately.
12428    /// - `group`: Assign the request to a custom stats group.
12429    pub async fn options_local<'a>(
12430        &'a self,
12431        async_: Option<bool>,
12432        group: Option<&'a str>,
12433    ) -> Result<ResponseValue<types::OptionsLocalResponse>, Error<types::RcError>> {
12434        let url = format!("{}/options/local", self.baseurl,);
12435        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12436        header_map.append(
12437            ::reqwest::header::HeaderName::from_static("api-version"),
12438            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12439        );
12440        #[allow(unused_mut)]
12441        let mut request = self
12442            .client
12443            .post(url)
12444            .header(
12445                ::reqwest::header::ACCEPT,
12446                ::reqwest::header::HeaderValue::from_static("application/json"),
12447            )
12448            .query(&progenitor_client::QueryParam::new("_async", &async_))
12449            .query(&progenitor_client::QueryParam::new("_group", &group))
12450            .headers(header_map)
12451            .build()?;
12452        let info = OperationInfo {
12453            operation_id: "options_local",
12454        };
12455        self.pre(&mut request, &info).await?;
12456        let result = self.exec(request, &info).await;
12457        self.post(&result, &info).await?;
12458        let response = result?;
12459        match response.status().as_u16() {
12460            200u16 => ResponseValue::from_response(response).await,
12461            400u16..=499u16 => Err(Error::ErrorResponse(
12462                ResponseValue::from_response(response).await?,
12463            )),
12464            500u16..=599u16 => Err(Error::ErrorResponse(
12465                ResponseValue::from_response(response).await?,
12466            )),
12467            _ => Err(Error::UnexpectedResponse(response)),
12468        }
12469    }
12470
12471    ///List serve instances
12472    ///
12473    ///Returns all running `rclone serve` instances with their IDs and options.
12474    ///
12475    ///Sends a `POST` request to `/serve/list`
12476    ///
12477    ///Arguments:
12478    /// - `async_`: Run the command asynchronously. Returns a job id
12479    ///   immediately.
12480    /// - `group`: Assign the request to a custom stats group.
12481    pub async fn serve_list<'a>(
12482        &'a self,
12483        async_: Option<bool>,
12484        group: Option<&'a str>,
12485    ) -> Result<ResponseValue<types::ServeListResponse>, Error<types::RcError>> {
12486        let url = format!("{}/serve/list", self.baseurl,);
12487        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12488        header_map.append(
12489            ::reqwest::header::HeaderName::from_static("api-version"),
12490            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12491        );
12492        #[allow(unused_mut)]
12493        let mut request = self
12494            .client
12495            .post(url)
12496            .header(
12497                ::reqwest::header::ACCEPT,
12498                ::reqwest::header::HeaderValue::from_static("application/json"),
12499            )
12500            .query(&progenitor_client::QueryParam::new("_async", &async_))
12501            .query(&progenitor_client::QueryParam::new("_group", &group))
12502            .headers(header_map)
12503            .build()?;
12504        let info = OperationInfo {
12505            operation_id: "serve_list",
12506        };
12507        self.pre(&mut request, &info).await?;
12508        let result = self.exec(request, &info).await;
12509        self.post(&result, &info).await?;
12510        let response = result?;
12511        match response.status().as_u16() {
12512            200u16 => ResponseValue::from_response(response).await,
12513            400u16..=499u16 => Err(Error::ErrorResponse(
12514                ResponseValue::from_response(response).await?,
12515            )),
12516            500u16..=599u16 => Err(Error::ErrorResponse(
12517                ResponseValue::from_response(response).await?,
12518            )),
12519            _ => Err(Error::UnexpectedResponse(response)),
12520        }
12521    }
12522
12523    ///Start serve instance
12524    ///
12525    ///Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with
12526    /// the provided parameters.
12527    ///
12528    ///Sends a `POST` request to `/serve/start`
12529    ///
12530    ///Arguments:
12531    /// - `async_`: Run the command asynchronously. Returns a job id
12532    ///   immediately.
12533    /// - `config`: JSON encoded config overrides applied for this call only.
12534    /// - `filter`: JSON encoded filter overrides applied for this call only.
12535    /// - `group`: Assign the request to a custom stats group.
12536    /// - `addr`: Address and port to bind the server to, such as `:5572` or
12537    ///   `localhost:8080`.
12538    /// - `fs`: Remote path that will be served.
12539    /// - `params`: Additional arbitrary parameters allowed.
12540    /// - `type_`: Type of server to start (e.g. `http`, `webdav`, `ftp`,
12541    ///   `sftp`).
12542    pub async fn serve_start<'a>(
12543        &'a self,
12544        async_: Option<bool>,
12545        config: Option<&'a str>,
12546        filter: Option<&'a str>,
12547        group: Option<&'a str>,
12548        addr: &'a str,
12549        fs: &'a str,
12550        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12551        type_: &'a str,
12552    ) -> Result<ResponseValue<types::ServeStartResponse>, Error<types::RcError>> {
12553        let url = format!("{}/serve/start", self.baseurl,);
12554        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12555        header_map.append(
12556            ::reqwest::header::HeaderName::from_static("api-version"),
12557            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12558        );
12559        #[allow(unused_mut)]
12560        let mut request = self
12561            .client
12562            .post(url)
12563            .header(
12564                ::reqwest::header::ACCEPT,
12565                ::reqwest::header::HeaderValue::from_static("application/json"),
12566            )
12567            .query(&progenitor_client::QueryParam::new("_async", &async_))
12568            .query(&progenitor_client::QueryParam::new("_config", &config))
12569            .query(&progenitor_client::QueryParam::new("_filter", &filter))
12570            .query(&progenitor_client::QueryParam::new("_group", &group))
12571            .query(&progenitor_client::QueryParam::new("addr", &addr))
12572            .query(&progenitor_client::QueryParam::new("fs", &fs))
12573            .query(&progenitor_client::QueryParam::new("params", &params))
12574            .query(&progenitor_client::QueryParam::new("type", &type_))
12575            .headers(header_map)
12576            .build()?;
12577        let info = OperationInfo {
12578            operation_id: "serve_start",
12579        };
12580        self.pre(&mut request, &info).await?;
12581        let result = self.exec(request, &info).await;
12582        self.post(&result, &info).await?;
12583        let response = result?;
12584        match response.status().as_u16() {
12585            200u16 => ResponseValue::from_response(response).await,
12586            400u16..=499u16 => Err(Error::ErrorResponse(
12587                ResponseValue::from_response(response).await?,
12588            )),
12589            500u16..=599u16 => Err(Error::ErrorResponse(
12590                ResponseValue::from_response(response).await?,
12591            )),
12592            _ => Err(Error::UnexpectedResponse(response)),
12593        }
12594    }
12595
12596    ///Stop serve instance
12597    ///
12598    ///Stops a running `serve` instance identified by its ID.
12599    ///
12600    ///Sends a `POST` request to `/serve/stop`
12601    ///
12602    ///Arguments:
12603    /// - `async_`: Run the command asynchronously. Returns a job id
12604    ///   immediately.
12605    /// - `group`: Assign the request to a custom stats group.
12606    /// - `id`: Identifier of the running serve instance returned by
12607    ///   `serve/start`.
12608    pub async fn serve_stop<'a>(
12609        &'a self,
12610        async_: Option<bool>,
12611        group: Option<&'a str>,
12612        id: &'a str,
12613    ) -> Result<
12614        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12615        Error<types::RcError>,
12616    > {
12617        let url = format!("{}/serve/stop", self.baseurl,);
12618        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12619        header_map.append(
12620            ::reqwest::header::HeaderName::from_static("api-version"),
12621            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12622        );
12623        #[allow(unused_mut)]
12624        let mut request = self
12625            .client
12626            .post(url)
12627            .header(
12628                ::reqwest::header::ACCEPT,
12629                ::reqwest::header::HeaderValue::from_static("application/json"),
12630            )
12631            .query(&progenitor_client::QueryParam::new("_async", &async_))
12632            .query(&progenitor_client::QueryParam::new("_group", &group))
12633            .query(&progenitor_client::QueryParam::new("id", &id))
12634            .headers(header_map)
12635            .build()?;
12636        let info = OperationInfo {
12637            operation_id: "serve_stop",
12638        };
12639        self.pre(&mut request, &info).await?;
12640        let result = self.exec(request, &info).await;
12641        self.post(&result, &info).await?;
12642        let response = result?;
12643        match response.status().as_u16() {
12644            200u16 => ResponseValue::from_response(response).await,
12645            400u16..=499u16 => Err(Error::ErrorResponse(
12646                ResponseValue::from_response(response).await?,
12647            )),
12648            500u16..=599u16 => Err(Error::ErrorResponse(
12649                ResponseValue::from_response(response).await?,
12650            )),
12651            _ => Err(Error::UnexpectedResponse(response)),
12652        }
12653    }
12654
12655    ///Stop all serve instances
12656    ///
12657    ///Stops every active `serve` instance.
12658    ///
12659    ///Sends a `POST` request to `/serve/stopall`
12660    ///
12661    ///Arguments:
12662    /// - `async_`: Run the command asynchronously. Returns a job id
12663    ///   immediately.
12664    /// - `group`: Assign the request to a custom stats group.
12665    pub async fn serve_stopall<'a>(
12666        &'a self,
12667        async_: Option<bool>,
12668        group: Option<&'a str>,
12669    ) -> Result<
12670        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12671        Error<types::RcError>,
12672    > {
12673        let url = format!("{}/serve/stopall", self.baseurl,);
12674        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12675        header_map.append(
12676            ::reqwest::header::HeaderName::from_static("api-version"),
12677            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12678        );
12679        #[allow(unused_mut)]
12680        let mut request = self
12681            .client
12682            .post(url)
12683            .header(
12684                ::reqwest::header::ACCEPT,
12685                ::reqwest::header::HeaderValue::from_static("application/json"),
12686            )
12687            .query(&progenitor_client::QueryParam::new("_async", &async_))
12688            .query(&progenitor_client::QueryParam::new("_group", &group))
12689            .headers(header_map)
12690            .build()?;
12691        let info = OperationInfo {
12692            operation_id: "serve_stopall",
12693        };
12694        self.pre(&mut request, &info).await?;
12695        let result = self.exec(request, &info).await;
12696        self.post(&result, &info).await?;
12697        let response = result?;
12698        match response.status().as_u16() {
12699            200u16 => ResponseValue::from_response(response).await,
12700            400u16..=499u16 => Err(Error::ErrorResponse(
12701                ResponseValue::from_response(response).await?,
12702            )),
12703            500u16..=599u16 => Err(Error::ErrorResponse(
12704                ResponseValue::from_response(response).await?,
12705            )),
12706            _ => Err(Error::UnexpectedResponse(response)),
12707        }
12708    }
12709
12710    ///List serve types
12711    ///
12712    ///Returns the list of supported `rclone serve` protocols.
12713    ///
12714    ///Sends a `POST` request to `/serve/types`
12715    ///
12716    ///Arguments:
12717    /// - `async_`: Run the command asynchronously. Returns a job id
12718    ///   immediately.
12719    /// - `group`: Assign the request to a custom stats group.
12720    pub async fn serve_types<'a>(
12721        &'a self,
12722        async_: Option<bool>,
12723        group: Option<&'a str>,
12724    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
12725        let url = format!("{}/serve/types", self.baseurl,);
12726        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12727        header_map.append(
12728            ::reqwest::header::HeaderName::from_static("api-version"),
12729            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12730        );
12731        #[allow(unused_mut)]
12732        let mut request = self
12733            .client
12734            .post(url)
12735            .header(
12736                ::reqwest::header::ACCEPT,
12737                ::reqwest::header::HeaderValue::from_static("application/json"),
12738            )
12739            .query(&progenitor_client::QueryParam::new("_async", &async_))
12740            .query(&progenitor_client::QueryParam::new("_group", &group))
12741            .headers(header_map)
12742            .build()?;
12743        let info = OperationInfo {
12744            operation_id: "serve_types",
12745        };
12746        self.pre(&mut request, &info).await?;
12747        let result = self.exec(request, &info).await;
12748        self.post(&result, &info).await?;
12749        let response = result?;
12750        match response.status().as_u16() {
12751            200u16 => Ok(ResponseValue::empty(response)),
12752            400u16..=499u16 => Err(Error::ErrorResponse(
12753                ResponseValue::from_response(response).await?,
12754            )),
12755            500u16..=599u16 => Err(Error::ErrorResponse(
12756                ResponseValue::from_response(response).await?,
12757            )),
12758            _ => Err(Error::UnexpectedResponse(response)),
12759        }
12760    }
12761
12762    ///Forget cached paths
12763    ///
12764    ///Evicts specific files or directories from the VFS directory cache.
12765    ///
12766    ///Sends a `POST` request to `/vfs/forget`
12767    ///
12768    ///Arguments:
12769    /// - `async_`: Run the command asynchronously. Returns a job id
12770    ///   immediately.
12771    /// - `group`: Assign the request to a custom stats group.
12772    /// - `fs`: Optional VFS identifier to target; required when more than one
12773    ///   VFS is active.
12774    /// - `params`: Additional arbitrary parameters allowed.
12775    pub async fn vfs_forget<'a>(
12776        &'a self,
12777        async_: Option<bool>,
12778        group: Option<&'a str>,
12779        fs: Option<&'a str>,
12780        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12781    ) -> Result<ResponseValue<types::VfsForgetResponse>, Error<types::RcError>> {
12782        let url = format!("{}/vfs/forget", self.baseurl,);
12783        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12784        header_map.append(
12785            ::reqwest::header::HeaderName::from_static("api-version"),
12786            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12787        );
12788        #[allow(unused_mut)]
12789        let mut request = self
12790            .client
12791            .post(url)
12792            .header(
12793                ::reqwest::header::ACCEPT,
12794                ::reqwest::header::HeaderValue::from_static("application/json"),
12795            )
12796            .query(&progenitor_client::QueryParam::new("_async", &async_))
12797            .query(&progenitor_client::QueryParam::new("_group", &group))
12798            .query(&progenitor_client::QueryParam::new("fs", &fs))
12799            .query(&progenitor_client::QueryParam::new("params", &params))
12800            .headers(header_map)
12801            .build()?;
12802        let info = OperationInfo {
12803            operation_id: "vfs_forget",
12804        };
12805        self.pre(&mut request, &info).await?;
12806        let result = self.exec(request, &info).await;
12807        self.post(&result, &info).await?;
12808        let response = result?;
12809        match response.status().as_u16() {
12810            200u16 => ResponseValue::from_response(response).await,
12811            400u16..=499u16 => Err(Error::ErrorResponse(
12812                ResponseValue::from_response(response).await?,
12813            )),
12814            500u16..=599u16 => Err(Error::ErrorResponse(
12815                ResponseValue::from_response(response).await?,
12816            )),
12817            _ => Err(Error::UnexpectedResponse(response)),
12818        }
12819    }
12820
12821    ///List VFS instances
12822    ///
12823    ///Lists the active VFS instances and their identifiers.
12824    ///
12825    ///Sends a `POST` request to `/vfs/list`
12826    ///
12827    ///Arguments:
12828    /// - `async_`: Run the command asynchronously. Returns a job id
12829    ///   immediately.
12830    /// - `group`: Assign the request to a custom stats group.
12831    /// - `fs`: Optional VFS identifier; omit to list all active VFS instances.
12832    pub async fn vfs_list<'a>(
12833        &'a self,
12834        async_: Option<bool>,
12835        group: Option<&'a str>,
12836        fs: Option<&'a str>,
12837    ) -> Result<ResponseValue<types::VfsListResponse>, Error<types::RcError>> {
12838        let url = format!("{}/vfs/list", 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("fs", &fs))
12855            .headers(header_map)
12856            .build()?;
12857        let info = OperationInfo {
12858            operation_id: "vfs_list",
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    ///Get or set poll interval
12877    ///
12878    ///Reads or updates the VFS poll interval duration, optionally waiting for
12879    /// the change to apply.
12880    ///
12881    ///Sends a `POST` request to `/vfs/poll-interval`
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    /// - `fs`: Optional VFS identifier whose poll interval should be queried or
12888    ///   modified.
12889    /// - `interval`: Duration string (e.g. `5m`) to set as the new poll
12890    ///   interval.
12891    /// - `timeout`: Duration to wait for the poll interval change to take
12892    ///   effect; `0` waits indefinitely.
12893    pub async fn vfs_poll_interval<'a>(
12894        &'a self,
12895        async_: Option<bool>,
12896        group: Option<&'a str>,
12897        fs: Option<&'a str>,
12898        interval: Option<&'a str>,
12899        timeout: Option<&'a str>,
12900    ) -> Result<
12901        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
12902        Error<types::RcError>,
12903    > {
12904        let url = format!("{}/vfs/poll-interval", self.baseurl,);
12905        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12906        header_map.append(
12907            ::reqwest::header::HeaderName::from_static("api-version"),
12908            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12909        );
12910        #[allow(unused_mut)]
12911        let mut request = self
12912            .client
12913            .post(url)
12914            .header(
12915                ::reqwest::header::ACCEPT,
12916                ::reqwest::header::HeaderValue::from_static("application/json"),
12917            )
12918            .query(&progenitor_client::QueryParam::new("_async", &async_))
12919            .query(&progenitor_client::QueryParam::new("_group", &group))
12920            .query(&progenitor_client::QueryParam::new("fs", &fs))
12921            .query(&progenitor_client::QueryParam::new("interval", &interval))
12922            .query(&progenitor_client::QueryParam::new("timeout", &timeout))
12923            .headers(header_map)
12924            .build()?;
12925        let info = OperationInfo {
12926            operation_id: "vfs_poll_interval",
12927        };
12928        self.pre(&mut request, &info).await?;
12929        let result = self.exec(request, &info).await;
12930        self.post(&result, &info).await?;
12931        let response = result?;
12932        match response.status().as_u16() {
12933            200u16 => ResponseValue::from_response(response).await,
12934            400u16..=499u16 => Err(Error::ErrorResponse(
12935                ResponseValue::from_response(response).await?,
12936            )),
12937            500u16..=599u16 => Err(Error::ErrorResponse(
12938                ResponseValue::from_response(response).await?,
12939            )),
12940            _ => Err(Error::UnexpectedResponse(response)),
12941        }
12942    }
12943
12944    ///Inspect upload queue
12945    ///
12946    ///Returns the contents of the VFS upload queue.
12947    ///
12948    ///Sends a `POST` request to `/vfs/queue`
12949    ///
12950    ///Arguments:
12951    /// - `async_`: Run the command asynchronously. Returns a job id
12952    ///   immediately.
12953    /// - `group`: Assign the request to a custom stats group.
12954    /// - `fs`: Optional VFS identifier whose upload queue should be inspected.
12955    pub async fn vfs_queue<'a>(
12956        &'a self,
12957        async_: Option<bool>,
12958        group: Option<&'a str>,
12959        fs: Option<&'a str>,
12960    ) -> Result<ResponseValue<types::VfsQueueResponse>, Error<types::RcError>> {
12961        let url = format!("{}/vfs/queue", self.baseurl,);
12962        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
12963        header_map.append(
12964            ::reqwest::header::HeaderName::from_static("api-version"),
12965            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
12966        );
12967        #[allow(unused_mut)]
12968        let mut request = self
12969            .client
12970            .post(url)
12971            .header(
12972                ::reqwest::header::ACCEPT,
12973                ::reqwest::header::HeaderValue::from_static("application/json"),
12974            )
12975            .query(&progenitor_client::QueryParam::new("_async", &async_))
12976            .query(&progenitor_client::QueryParam::new("_group", &group))
12977            .query(&progenitor_client::QueryParam::new("fs", &fs))
12978            .headers(header_map)
12979            .build()?;
12980        let info = OperationInfo {
12981            operation_id: "vfs_queue",
12982        };
12983        self.pre(&mut request, &info).await?;
12984        let result = self.exec(request, &info).await;
12985        self.post(&result, &info).await?;
12986        let response = result?;
12987        match response.status().as_u16() {
12988            200u16 => ResponseValue::from_response(response).await,
12989            400u16..=499u16 => Err(Error::ErrorResponse(
12990                ResponseValue::from_response(response).await?,
12991            )),
12992            500u16..=599u16 => Err(Error::ErrorResponse(
12993                ResponseValue::from_response(response).await?,
12994            )),
12995            _ => Err(Error::UnexpectedResponse(response)),
12996        }
12997    }
12998
12999    ///Adjust queue expiry
13000    ///
13001    ///Sets the expiry time of a queued VFS upload item, optionally relative to
13002    /// its current value.
13003    ///
13004    ///Sends a `POST` request to `/vfs/queue-set-expiry`
13005    ///
13006    ///Arguments:
13007    /// - `async_`: Run the command asynchronously. Returns a job id
13008    ///   immediately.
13009    /// - `group`: Assign the request to a custom stats group.
13010    /// - `expiry`: New eligibility time in seconds (may be negative for
13011    ///   immediate upload).
13012    /// - `fs`: Optional VFS identifier for the queued item.
13013    /// - `id`: Queue item ID as returned by `vfs/queue`.
13014    /// - `relative`: Set to true to treat `expiry` as relative to the current
13015    ///   value.
13016    pub async fn vfs_queue_set_expiry<'a>(
13017        &'a self,
13018        async_: Option<bool>,
13019        group: Option<&'a str>,
13020        expiry: f64,
13021        fs: Option<&'a str>,
13022        id: i64,
13023        relative: Option<bool>,
13024    ) -> Result<
13025        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13026        Error<types::RcError>,
13027    > {
13028        let url = format!("{}/vfs/queue-set-expiry", self.baseurl,);
13029        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13030        header_map.append(
13031            ::reqwest::header::HeaderName::from_static("api-version"),
13032            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13033        );
13034        #[allow(unused_mut)]
13035        let mut request = self
13036            .client
13037            .post(url)
13038            .header(
13039                ::reqwest::header::ACCEPT,
13040                ::reqwest::header::HeaderValue::from_static("application/json"),
13041            )
13042            .query(&progenitor_client::QueryParam::new("_async", &async_))
13043            .query(&progenitor_client::QueryParam::new("_group", &group))
13044            .query(&progenitor_client::QueryParam::new("expiry", &expiry))
13045            .query(&progenitor_client::QueryParam::new("fs", &fs))
13046            .query(&progenitor_client::QueryParam::new("id", &id))
13047            .query(&progenitor_client::QueryParam::new("relative", &relative))
13048            .headers(header_map)
13049            .build()?;
13050        let info = OperationInfo {
13051            operation_id: "vfs_queue_set_expiry",
13052        };
13053        self.pre(&mut request, &info).await?;
13054        let result = self.exec(request, &info).await;
13055        self.post(&result, &info).await?;
13056        let response = result?;
13057        match response.status().as_u16() {
13058            200u16 => ResponseValue::from_response(response).await,
13059            400u16..=499u16 => Err(Error::ErrorResponse(
13060                ResponseValue::from_response(response).await?,
13061            )),
13062            500u16..=599u16 => Err(Error::ErrorResponse(
13063                ResponseValue::from_response(response).await?,
13064            )),
13065            _ => Err(Error::UnexpectedResponse(response)),
13066        }
13067    }
13068
13069    ///Refresh directory cache
13070    ///
13071    ///Refreshes one or more directories in the VFS cache, optionally
13072    /// recursively.
13073    ///
13074    ///Sends a `POST` request to `/vfs/refresh`
13075    ///
13076    ///Arguments:
13077    /// - `async_`: Run the command asynchronously. Returns a job id
13078    ///   immediately.
13079    /// - `group`: Assign the request to a custom stats group.
13080    /// - `fs`: Optional VFS identifier whose directory cache should be
13081    ///   refreshed.
13082    /// - `params`: Additional arbitrary parameters allowed.
13083    /// - `recursive`: Set to true to refresh entire directory trees.
13084    pub async fn vfs_refresh<'a>(
13085        &'a self,
13086        async_: Option<bool>,
13087        group: Option<&'a str>,
13088        fs: Option<&'a str>,
13089        params: Option<&'a ::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13090        recursive: Option<bool>,
13091    ) -> Result<ResponseValue<types::VfsRefreshResponse>, Error<types::RcError>> {
13092        let url = format!("{}/vfs/refresh", self.baseurl,);
13093        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13094        header_map.append(
13095            ::reqwest::header::HeaderName::from_static("api-version"),
13096            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13097        );
13098        #[allow(unused_mut)]
13099        let mut request = self
13100            .client
13101            .post(url)
13102            .header(
13103                ::reqwest::header::ACCEPT,
13104                ::reqwest::header::HeaderValue::from_static("application/json"),
13105            )
13106            .query(&progenitor_client::QueryParam::new("_async", &async_))
13107            .query(&progenitor_client::QueryParam::new("_group", &group))
13108            .query(&progenitor_client::QueryParam::new("fs", &fs))
13109            .query(&progenitor_client::QueryParam::new("params", &params))
13110            .query(&progenitor_client::QueryParam::new("recursive", &recursive))
13111            .headers(header_map)
13112            .build()?;
13113        let info = OperationInfo {
13114            operation_id: "vfs_refresh",
13115        };
13116        self.pre(&mut request, &info).await?;
13117        let result = self.exec(request, &info).await;
13118        self.post(&result, &info).await?;
13119        let response = result?;
13120        match response.status().as_u16() {
13121            200u16 => ResponseValue::from_response(response).await,
13122            400u16..=499u16 => Err(Error::ErrorResponse(
13123                ResponseValue::from_response(response).await?,
13124            )),
13125            500u16..=599u16 => Err(Error::ErrorResponse(
13126                ResponseValue::from_response(response).await?,
13127            )),
13128            _ => Err(Error::UnexpectedResponse(response)),
13129        }
13130    }
13131
13132    ///Show VFS stats
13133    ///
13134    ///Returns VFS statistics including disk cache usage and metadata cache
13135    /// counters.
13136    ///
13137    ///Sends a `POST` request to `/vfs/stats`
13138    ///
13139    ///Arguments:
13140    /// - `async_`: Run the command asynchronously. Returns a job id
13141    ///   immediately.
13142    /// - `group`: Assign the request to a custom stats group.
13143    /// - `fs`: Optional VFS identifier whose statistics should be returned.
13144    pub async fn vfs_stats<'a>(
13145        &'a self,
13146        async_: Option<bool>,
13147        group: Option<&'a str>,
13148        fs: Option<&'a str>,
13149    ) -> Result<ResponseValue<types::VfsStatsResponse>, Error<types::RcError>> {
13150        let url = format!("{}/vfs/stats", self.baseurl,);
13151        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13152        header_map.append(
13153            ::reqwest::header::HeaderName::from_static("api-version"),
13154            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13155        );
13156        #[allow(unused_mut)]
13157        let mut request = self
13158            .client
13159            .post(url)
13160            .header(
13161                ::reqwest::header::ACCEPT,
13162                ::reqwest::header::HeaderValue::from_static("application/json"),
13163            )
13164            .query(&progenitor_client::QueryParam::new("_async", &async_))
13165            .query(&progenitor_client::QueryParam::new("_group", &group))
13166            .query(&progenitor_client::QueryParam::new("fs", &fs))
13167            .headers(header_map)
13168            .build()?;
13169        let info = OperationInfo {
13170            operation_id: "vfs_stats",
13171        };
13172        self.pre(&mut request, &info).await?;
13173        let result = self.exec(request, &info).await;
13174        self.post(&result, &info).await?;
13175        let response = result?;
13176        match response.status().as_u16() {
13177            200u16 => ResponseValue::from_response(response).await,
13178            400u16..=499u16 => Err(Error::ErrorResponse(
13179                ResponseValue::from_response(response).await?,
13180            )),
13181            500u16..=599u16 => Err(Error::ErrorResponse(
13182                ResponseValue::from_response(response).await?,
13183            )),
13184            _ => Err(Error::UnexpectedResponse(response)),
13185        }
13186    }
13187
13188    ///Install plugin
13189    ///
13190    ///Downloads and installs a plugin into the WebUI from the provided
13191    /// repository URL.
13192    ///
13193    ///Sends a `POST` request to `/pluginsctl/addPlugin`
13194    ///
13195    ///Arguments:
13196    /// - `async_`: Run the command asynchronously. Returns a job id
13197    ///   immediately.
13198    /// - `group`: Assign the request to a custom stats group.
13199    /// - `url`: Repository URL of the plugin to install.
13200    pub async fn pluginsctl_add_plugin<'a>(
13201        &'a self,
13202        async_: Option<bool>,
13203        group: Option<&'a str>,
13204        url: &'a str,
13205    ) -> Result<
13206        ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
13207        Error<types::RcError>,
13208    > {
13209        let _url = format!("{}/pluginsctl/addPlugin", self.baseurl,);
13210        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13211        header_map.append(
13212            ::reqwest::header::HeaderName::from_static("api-version"),
13213            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13214        );
13215        #[allow(unused_mut)]
13216        let mut request = self
13217            .client
13218            .post(_url)
13219            .header(
13220                ::reqwest::header::ACCEPT,
13221                ::reqwest::header::HeaderValue::from_static("application/json"),
13222            )
13223            .query(&progenitor_client::QueryParam::new("_async", &async_))
13224            .query(&progenitor_client::QueryParam::new("_group", &group))
13225            .query(&progenitor_client::QueryParam::new("url", &url))
13226            .headers(header_map)
13227            .build()?;
13228        let info = OperationInfo {
13229            operation_id: "pluginsctl_add_plugin",
13230        };
13231        self.pre(&mut request, &info).await?;
13232        let result = self.exec(request, &info).await;
13233        self.post(&result, &info).await?;
13234        let response = result?;
13235        match response.status().as_u16() {
13236            200u16 => ResponseValue::from_response(response).await,
13237            400u16..=499u16 => Err(Error::ErrorResponse(
13238                ResponseValue::from_response(response).await?,
13239            )),
13240            500u16..=599u16 => Err(Error::ErrorResponse(
13241                ResponseValue::from_response(response).await?,
13242            )),
13243            _ => Err(Error::UnexpectedResponse(response)),
13244        }
13245    }
13246
13247    ///Filter plugins by MIME type
13248    ///
13249    ///Returns plugins matching the requested MIME type and optional plugin
13250    /// type.
13251    ///
13252    ///Sends a `POST` request to `/pluginsctl/getPluginsForType`
13253    ///
13254    ///Arguments:
13255    /// - `async_`: Run the command asynchronously. Returns a job id
13256    ///   immediately.
13257    /// - `group`: Assign the request to a custom stats group.
13258    /// - `plugin_type`: Filter results by plugin type (e.g. `test`).
13259    /// - `type_`: MIME type to match when listing plugins.
13260    pub async fn pluginsctl_get_plugins_for_type<'a>(
13261        &'a self,
13262        async_: Option<bool>,
13263        group: Option<&'a str>,
13264        plugin_type: Option<&'a str>,
13265        type_: Option<&'a str>,
13266    ) -> Result<ResponseValue<types::PluginsctlGetPluginsForTypeResponse>, Error<types::RcError>>
13267    {
13268        let url = format!("{}/pluginsctl/getPluginsForType", self.baseurl,);
13269        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13270        header_map.append(
13271            ::reqwest::header::HeaderName::from_static("api-version"),
13272            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13273        );
13274        #[allow(unused_mut)]
13275        let mut request = self
13276            .client
13277            .post(url)
13278            .header(
13279                ::reqwest::header::ACCEPT,
13280                ::reqwest::header::HeaderValue::from_static("application/json"),
13281            )
13282            .query(&progenitor_client::QueryParam::new("_async", &async_))
13283            .query(&progenitor_client::QueryParam::new("_group", &group))
13284            .query(&progenitor_client::QueryParam::new(
13285                "pluginType",
13286                &plugin_type,
13287            ))
13288            .query(&progenitor_client::QueryParam::new("type", &type_))
13289            .headers(header_map)
13290            .build()?;
13291        let info = OperationInfo {
13292            operation_id: "pluginsctl_get_plugins_for_type",
13293        };
13294        self.pre(&mut request, &info).await?;
13295        let result = self.exec(request, &info).await;
13296        self.post(&result, &info).await?;
13297        let response = result?;
13298        match response.status().as_u16() {
13299            200u16 => ResponseValue::from_response(response).await,
13300            400u16..=499u16 => Err(Error::ErrorResponse(
13301                ResponseValue::from_response(response).await?,
13302            )),
13303            500u16..=599u16 => Err(Error::ErrorResponse(
13304                ResponseValue::from_response(response).await?,
13305            )),
13306            _ => Err(Error::UnexpectedResponse(response)),
13307        }
13308    }
13309
13310    ///List installed plugins
13311    ///
13312    ///Returns metadata for installed production and test plugins.
13313    ///
13314    ///Sends a `POST` request to `/pluginsctl/listPlugins`
13315    ///
13316    ///Arguments:
13317    /// - `async_`: Run the command asynchronously. Returns a job id
13318    ///   immediately.
13319    /// - `group`: Assign the request to a custom stats group.
13320    pub async fn pluginsctl_list_plugins<'a>(
13321        &'a self,
13322        async_: Option<bool>,
13323        group: Option<&'a str>,
13324    ) -> Result<ResponseValue<types::PluginsctlListPluginsResponse>, Error<types::RcError>> {
13325        let url = format!("{}/pluginsctl/listPlugins", self.baseurl,);
13326        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13327        header_map.append(
13328            ::reqwest::header::HeaderName::from_static("api-version"),
13329            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13330        );
13331        #[allow(unused_mut)]
13332        let mut request = self
13333            .client
13334            .post(url)
13335            .header(
13336                ::reqwest::header::ACCEPT,
13337                ::reqwest::header::HeaderValue::from_static("application/json"),
13338            )
13339            .query(&progenitor_client::QueryParam::new("_async", &async_))
13340            .query(&progenitor_client::QueryParam::new("_group", &group))
13341            .headers(header_map)
13342            .build()?;
13343        let info = OperationInfo {
13344            operation_id: "pluginsctl_list_plugins",
13345        };
13346        self.pre(&mut request, &info).await?;
13347        let result = self.exec(request, &info).await;
13348        self.post(&result, &info).await?;
13349        let response = result?;
13350        match response.status().as_u16() {
13351            200u16 => ResponseValue::from_response(response).await,
13352            400u16..=499u16 => Err(Error::ErrorResponse(
13353                ResponseValue::from_response(response).await?,
13354            )),
13355            500u16..=599u16 => Err(Error::ErrorResponse(
13356                ResponseValue::from_response(response).await?,
13357            )),
13358            _ => Err(Error::UnexpectedResponse(response)),
13359        }
13360    }
13361
13362    ///List installed test plugins
13363    ///
13364    ///Returns metadata for installed test plugins.
13365    ///
13366    ///Sends a `POST` request to `/pluginsctl/listTestPlugins`
13367    ///
13368    ///Arguments:
13369    /// - `async_`: Run the command asynchronously. Returns a job id
13370    ///   immediately.
13371    /// - `group`: Assign the request to a custom stats group.
13372    pub async fn pluginsctl_list_test_plugins<'a>(
13373        &'a self,
13374        async_: Option<bool>,
13375        group: Option<&'a str>,
13376    ) -> Result<ResponseValue<types::PluginsctlListTestPluginsResponse>, Error<types::RcError>>
13377    {
13378        let url = format!("{}/pluginsctl/listTestPlugins", self.baseurl,);
13379        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13380        header_map.append(
13381            ::reqwest::header::HeaderName::from_static("api-version"),
13382            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13383        );
13384        #[allow(unused_mut)]
13385        let mut request = self
13386            .client
13387            .post(url)
13388            .header(
13389                ::reqwest::header::ACCEPT,
13390                ::reqwest::header::HeaderValue::from_static("application/json"),
13391            )
13392            .query(&progenitor_client::QueryParam::new("_async", &async_))
13393            .query(&progenitor_client::QueryParam::new("_group", &group))
13394            .headers(header_map)
13395            .build()?;
13396        let info = OperationInfo {
13397            operation_id: "pluginsctl_list_test_plugins",
13398        };
13399        self.pre(&mut request, &info).await?;
13400        let result = self.exec(request, &info).await;
13401        self.post(&result, &info).await?;
13402        let response = result?;
13403        match response.status().as_u16() {
13404            200u16 => ResponseValue::from_response(response).await,
13405            400u16..=499u16 => Err(Error::ErrorResponse(
13406                ResponseValue::from_response(response).await?,
13407            )),
13408            500u16..=599u16 => Err(Error::ErrorResponse(
13409                ResponseValue::from_response(response).await?,
13410            )),
13411            _ => Err(Error::UnexpectedResponse(response)),
13412        }
13413    }
13414
13415    ///Remove plugin
13416    ///
13417    ///Uninstalls a plugin from the WebUI.
13418    ///
13419    ///Sends a `POST` request to `/pluginsctl/removePlugin`
13420    ///
13421    ///Arguments:
13422    /// - `async_`: Run the command asynchronously. Returns a job id
13423    ///   immediately.
13424    /// - `group`: Assign the request to a custom stats group.
13425    /// - `name`: Name of the plugin to uninstall.
13426    pub async fn pluginsctl_remove_plugin<'a>(
13427        &'a self,
13428        async_: Option<bool>,
13429        group: Option<&'a str>,
13430        name: &'a str,
13431    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
13432        let url = format!("{}/pluginsctl/removePlugin", 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("name", &name))
13449            .headers(header_map)
13450            .build()?;
13451        let info = OperationInfo {
13452            operation_id: "pluginsctl_remove_plugin",
13453        };
13454        self.pre(&mut request, &info).await?;
13455        let result = self.exec(request, &info).await;
13456        self.post(&result, &info).await?;
13457        let response = result?;
13458        match response.status().as_u16() {
13459            200u16 => Ok(ResponseValue::empty(response)),
13460            400u16..=499u16 => Err(Error::ErrorResponse(
13461                ResponseValue::from_response(response).await?,
13462            )),
13463            500u16..=599u16 => Err(Error::ErrorResponse(
13464                ResponseValue::from_response(response).await?,
13465            )),
13466            _ => Err(Error::UnexpectedResponse(response)),
13467        }
13468    }
13469
13470    ///Remove test plugin
13471    ///
13472    ///Uninstalls a test plugin from the WebUI.
13473    ///
13474    ///Sends a `POST` request to `/pluginsctl/removeTestPlugin`
13475    ///
13476    ///Arguments:
13477    /// - `async_`: Run the command asynchronously. Returns a job id
13478    ///   immediately.
13479    /// - `group`: Assign the request to a custom stats group.
13480    /// - `name`: Name of the test plugin to uninstall.
13481    pub async fn pluginsctl_remove_test_plugin<'a>(
13482        &'a self,
13483        async_: Option<bool>,
13484        group: Option<&'a str>,
13485        name: &'a str,
13486    ) -> Result<ResponseValue<()>, Error<types::RcError>> {
13487        let url = format!("{}/pluginsctl/removeTestPlugin", self.baseurl,);
13488        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
13489        header_map.append(
13490            ::reqwest::header::HeaderName::from_static("api-version"),
13491            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
13492        );
13493        #[allow(unused_mut)]
13494        let mut request = self
13495            .client
13496            .post(url)
13497            .header(
13498                ::reqwest::header::ACCEPT,
13499                ::reqwest::header::HeaderValue::from_static("application/json"),
13500            )
13501            .query(&progenitor_client::QueryParam::new("_async", &async_))
13502            .query(&progenitor_client::QueryParam::new("_group", &group))
13503            .query(&progenitor_client::QueryParam::new("name", &name))
13504            .headers(header_map)
13505            .build()?;
13506        let info = OperationInfo {
13507            operation_id: "pluginsctl_remove_test_plugin",
13508        };
13509        self.pre(&mut request, &info).await?;
13510        let result = self.exec(request, &info).await;
13511        self.post(&result, &info).await?;
13512        let response = result?;
13513        match response.status().as_u16() {
13514            200u16 => Ok(ResponseValue::empty(response)),
13515            400u16..=499u16 => Err(Error::ErrorResponse(
13516                ResponseValue::from_response(response).await?,
13517            )),
13518            500u16..=599u16 => Err(Error::ErrorResponse(
13519                ResponseValue::from_response(response).await?,
13520            )),
13521            _ => Err(Error::UnexpectedResponse(response)),
13522        }
13523    }
13524}
13525
13526/// Items consumers will typically use such as the Client.
13527pub mod prelude {
13528    #[allow(unused_imports)]
13529    pub use super::Client;
13530}
rclone_sdk/lib.rs

rclone_sdk/
lib.rs
