1#[derive(Debug, Clone)]
2pub struct OptionsClient<T> {
3 client: T,
4 path: String,
5}
6impl<T> OptionsClient<T>
7where
8 T: crate::client::Client,
9{
10 pub fn new(client: T, parent_path: &str) -> Self {
11 Self {
12 client,
13 path: format!("{}{}", parent_path, "/options"),
14 }
15 }
16}
17impl<T> OptionsClient<T>
18where
19 T: crate::client::Client,
20{
21 #[doc = "Get datacenter options. Without 'Sys.Audit' on '/' not all options are returned."]
22 #[doc = ""]
23 #[doc = "Permission check: perm(\"/\", [\"Sys.Audit\"])"]
24 pub async fn get(&self) -> Result<GetOutput, T::Error> {
25 let path = self.path.to_string();
26 self.client.get(&path, &()).await
27 }
28}
29impl<T> OptionsClient<T>
30where
31 T: crate::client::Client,
32{
33 #[doc = "Set datacenter options."]
34 #[doc = ""]
35 #[doc = "Permission check: perm(\"/\", [\"Sys.Modify\"])"]
36 pub async fn put(&self, params: PutParams) -> Result<(), T::Error> {
37 let path = self.path.to_string();
38 self.client.put(&path, ¶ms).await
39 }
40}
41#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
42pub struct GetOutput {
43 #[serde(
44 flatten,
45 default,
46 skip_serializing_if = "::std::collections::HashMap::is_empty"
47 )]
48 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
49}
50#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
51pub struct PutParams {
52 #[serde(skip_serializing_if = "Option::is_none", default)]
53 #[doc = "Set I/O bandwidth limit for various operations (in KiB/s)."]
54 #[doc = ""]
55 pub bwlimit: Option<String>,
56 #[serde(rename = "consent-text")]
57 #[serde(skip_serializing_if = "Option::is_none", default)]
58 #[doc = "Consent text that is displayed before logging in."]
59 #[doc = ""]
60 pub consent_text: Option<ConsentTextStr>,
61 #[serde(skip_serializing_if = "Option::is_none", default)]
62 #[doc = "Select the default Console viewer. You can either use the builtin java applet (VNC; deprecated and maps to html5), an external virt-viewer comtatible application (SPICE), an HTML5 based vnc viewer (noVNC), or an HTML5 based console client (xtermjs). If the selected viewer is not available (e.g. SPICE not activated for the VM), the fallback is noVNC."]
63 #[doc = ""]
64 pub console: Option<Console>,
65 #[serde(skip_serializing_if = "Option::is_none", default)]
66 #[doc = "Cluster resource scheduling settings."]
67 #[doc = ""]
68 pub crs: Option<String>,
69 #[serde(skip_serializing_if = "Option::is_none", default)]
70 #[doc = "A list of settings you want to delete."]
71 #[doc = ""]
72 pub delete: Option<String>,
73 #[serde(skip_serializing_if = "Option::is_none", default)]
74 #[doc = "Datacenter description. Shown in the web-interface datacenter notes panel. This is saved as comment inside the configuration file."]
75 #[doc = ""]
76 pub description: Option<DescriptionStr>,
77 #[serde(skip_serializing_if = "Option::is_none", default)]
78 #[doc = "Specify email address to send notification from (default is root@$hostname)"]
79 #[doc = ""]
80 pub email_from: Option<String>,
81 #[serde(skip_serializing_if = "Option::is_none", default)]
82 #[doc = "Set the fencing mode of the HA cluster. Hardware mode needs a valid configuration of fence devices in /etc/pve/ha/fence.cfg. With both all two modes are used."]
83 #[doc = ""]
84 #[doc = "WARNING: 'hardware' and 'both' are EXPERIMENTAL & WIP"]
85 #[doc = ""]
86 pub fencing: Option<Fencing>,
87 #[serde(skip_serializing_if = "Option::is_none", default)]
88 #[doc = "Cluster wide HA settings."]
89 #[doc = ""]
90 pub ha: Option<String>,
91 #[serde(skip_serializing_if = "Option::is_none", default)]
92 #[doc = "Specify external http proxy which is used for downloads (example: 'http://username:password@host:port/')"]
93 #[doc = ""]
94 pub http_proxy: Option<HttpProxyStr>,
95 #[serde(skip_serializing_if = "Option::is_none", default)]
96 #[doc = "Default keybord layout for vnc server."]
97 #[doc = ""]
98 pub keyboard: Option<Keyboard>,
99 #[serde(skip_serializing_if = "Option::is_none", default)]
100 #[doc = "Default GUI language."]
101 #[doc = ""]
102 pub language: Option<Language>,
103 #[serde(skip_serializing_if = "Option::is_none", default)]
104 #[doc = "Prefix for the auto-generated MAC addresses of virtual guests. The default 'BC:24:11' is the OUI assigned by the IEEE to Proxmox Server Solutions GmbH for a 24-bit large MAC block. You're allowed to use this in local networks, i.e., those not directly reachable by the public (e.g., in a LAN or behind NAT)."]
105 #[doc = ""]
106 #[doc = "Prefix for the auto-generated MAC addresses of virtual guests. The default `BC:24:11` is the Organizationally Unique Identifier (OUI) assigned by the IEEE to Proxmox Server Solutions GmbH for a MAC Address Block Large (MA-L). You're allowed to use this in local networks, i.e., those not directly reachable by the public (e.g., in a LAN or NAT/Masquerading)."]
107 #[doc = ""]
108 #[doc = "Note that when you run multiple cluster that (partially) share the networks of their virtual guests, it's highly recommended that you extend the default MAC prefix, or generate a custom (valid) one, to reduce the chance of MAC collisions. For example, add a separate extra hexadecimal to the Proxmox OUI for each cluster, like `BC:24:11:0` for the first, `BC:24:11:1` for the second, and so on."]
109 #[doc = ""]
110 #[doc = "Alternatively, you can also separate the networks of the guests logically, e.g., by using VLANs."]
111 #[doc = ""]
112 #[doc = "For publicly accessible guests it's recommended that you get your own https://standards.ieee.org/products-programs/regauth/\\\\[OUI from the IEEE\\\\] registered or coordinate with your, or your hosting providers, network admins."]
113 #[doc = ""]
114 pub mac_prefix: Option<String>,
115 #[serde(
116 serialize_with = "crate::types::serialize_non_zero_pos_int_optional",
117 deserialize_with = "crate::types::deserialize_non_zero_pos_int_optional"
118 )]
119 #[serde(skip_serializing_if = "Option::is_none", default)]
120 #[doc = "Defines how many workers (per node) are maximal started on actions like 'stopall VMs' or task from the ha-manager."]
121 #[doc = ""]
122 pub max_workers: Option<std::num::NonZeroU64>,
123 #[serde(skip_serializing_if = "Option::is_none", default)]
124 #[doc = "For cluster wide migration settings."]
125 #[doc = ""]
126 pub migration: Option<String>,
127 #[serde(
128 serialize_with = "crate::types::serialize_bool_optional",
129 deserialize_with = "crate::types::deserialize_bool_optional"
130 )]
131 #[serde(skip_serializing_if = "Option::is_none", default)]
132 #[doc = "Migration is secure using SSH tunnel by default. For secure private networks you can disable it to speed up migration. Deprecated, use the 'migration' property instead!"]
133 #[doc = ""]
134 pub migration_unsecure: Option<bool>,
135 #[serde(rename = "next-id")]
136 #[serde(skip_serializing_if = "Option::is_none", default)]
137 #[doc = "Control the range for the free VMID auto-selection pool."]
138 #[doc = ""]
139 pub next_id: Option<String>,
140 #[serde(skip_serializing_if = "Option::is_none", default)]
141 #[doc = "Cluster-wide notification settings."]
142 #[doc = ""]
143 pub notify: Option<String>,
144 #[serde(rename = "registered-tags")]
145 #[serde(skip_serializing_if = "Option::is_none", default)]
146 #[doc = "A list of tags that require a `Sys.Modify` on '/' to set and delete. Tags set here that are also in 'user-tag-access' also require `Sys.Modify`."]
147 #[doc = ""]
148 pub registered_tags: Option<RegisteredTagsStr>,
149 #[serde(skip_serializing_if = "Option::is_none", default)]
150 #[doc = "For cluster wide replication settings."]
151 #[doc = ""]
152 pub replication: Option<String>,
153 #[serde(rename = "tag-style")]
154 #[serde(skip_serializing_if = "Option::is_none", default)]
155 #[doc = "Tag style options."]
156 #[doc = ""]
157 pub tag_style: Option<String>,
158 #[serde(skip_serializing_if = "Option::is_none", default)]
159 #[doc = "u2f"]
160 #[doc = ""]
161 pub u2f: Option<String>,
162 #[serde(rename = "user-tag-access")]
163 #[serde(skip_serializing_if = "Option::is_none", default)]
164 #[doc = "Privilege options for user-settable tags"]
165 #[doc = ""]
166 pub user_tag_access: Option<String>,
167 #[serde(skip_serializing_if = "Option::is_none", default)]
168 #[doc = "webauthn configuration"]
169 #[doc = ""]
170 pub webauthn: Option<String>,
171 #[serde(
172 flatten,
173 default,
174 skip_serializing_if = "::std::collections::HashMap::is_empty"
175 )]
176 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
177}
178#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
179#[doc = "Select the default Console viewer. You can either use the builtin java applet (VNC; deprecated and maps to html5), an external virt-viewer comtatible application (SPICE), an HTML5 based vnc viewer (noVNC), or an HTML5 based console client (xtermjs). If the selected viewer is not available (e.g. SPICE not activated for the VM), the fallback is noVNC."]
180#[doc = ""]
181pub enum Console {
182 #[serde(rename = "applet")]
183 Applet,
184 #[serde(rename = "html5")]
185 Html5,
186 #[serde(rename = "vv")]
187 Vv,
188 #[serde(rename = "xtermjs")]
189 Xtermjs,
190}
191impl TryFrom<&str> for Console {
192 type Error = String;
193 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
194 match value {
195 "applet" => Ok(Self::Applet),
196 "html5" => Ok(Self::Html5),
197 "vv" => Ok(Self::Vv),
198 "xtermjs" => Ok(Self::Xtermjs),
199 v => Err(format!("Unknown variant {v}")),
200 }
201 }
202}
203#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq, Default)]
204#[doc = "Set the fencing mode of the HA cluster. Hardware mode needs a valid configuration of fence devices in /etc/pve/ha/fence.cfg. With both all two modes are used."]
205#[doc = ""]
206#[doc = "WARNING: 'hardware' and 'both' are EXPERIMENTAL & WIP"]
207#[doc = ""]
208pub enum Fencing {
209 #[serde(rename = "both")]
210 Both,
211 #[serde(rename = "hardware")]
212 Hardware,
213 #[serde(rename = "watchdog")]
214 #[default]
215 Watchdog,
216}
217impl TryFrom<&str> for Fencing {
218 type Error = String;
219 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
220 match value {
221 "both" => Ok(Self::Both),
222 "hardware" => Ok(Self::Hardware),
223 "watchdog" => Ok(Self::Watchdog),
224 v => Err(format!("Unknown variant {v}")),
225 }
226 }
227}
228#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
229#[doc = "Default keybord layout for vnc server."]
230#[doc = ""]
231pub enum Keyboard {
232 #[serde(rename = "da")]
233 Da,
234 #[serde(rename = "de")]
235 De,
236 #[serde(rename = "de-ch")]
237 DeCh,
238 #[serde(rename = "en-gb")]
239 EnGb,
240 #[serde(rename = "en-us")]
241 EnUs,
242 #[serde(rename = "es")]
243 Es,
244 #[serde(rename = "fi")]
245 Fi,
246 #[serde(rename = "fr")]
247 Fr,
248 #[serde(rename = "fr-be")]
249 FrBe,
250 #[serde(rename = "fr-ca")]
251 FrCa,
252 #[serde(rename = "fr-ch")]
253 FrCh,
254 #[serde(rename = "hu")]
255 Hu,
256 #[serde(rename = "is")]
257 Is,
258 #[serde(rename = "it")]
259 It,
260 #[serde(rename = "ja")]
261 Ja,
262 #[serde(rename = "lt")]
263 Lt,
264 #[serde(rename = "mk")]
265 Mk,
266 #[serde(rename = "nl")]
267 Nl,
268 #[serde(rename = "no")]
269 No,
270 #[serde(rename = "pl")]
271 Pl,
272 #[serde(rename = "pt")]
273 Pt,
274 #[serde(rename = "pt-br")]
275 PtBr,
276 #[serde(rename = "sl")]
277 Sl,
278 #[serde(rename = "sv")]
279 Sv,
280 #[serde(rename = "tr")]
281 Tr,
282}
283impl TryFrom<&str> for Keyboard {
284 type Error = String;
285 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
286 match value {
287 "da" => Ok(Self::Da),
288 "de" => Ok(Self::De),
289 "de-ch" => Ok(Self::DeCh),
290 "en-gb" => Ok(Self::EnGb),
291 "en-us" => Ok(Self::EnUs),
292 "es" => Ok(Self::Es),
293 "fi" => Ok(Self::Fi),
294 "fr" => Ok(Self::Fr),
295 "fr-be" => Ok(Self::FrBe),
296 "fr-ca" => Ok(Self::FrCa),
297 "fr-ch" => Ok(Self::FrCh),
298 "hu" => Ok(Self::Hu),
299 "is" => Ok(Self::Is),
300 "it" => Ok(Self::It),
301 "ja" => Ok(Self::Ja),
302 "lt" => Ok(Self::Lt),
303 "mk" => Ok(Self::Mk),
304 "nl" => Ok(Self::Nl),
305 "no" => Ok(Self::No),
306 "pl" => Ok(Self::Pl),
307 "pt" => Ok(Self::Pt),
308 "pt-br" => Ok(Self::PtBr),
309 "sl" => Ok(Self::Sl),
310 "sv" => Ok(Self::Sv),
311 "tr" => Ok(Self::Tr),
312 v => Err(format!("Unknown variant {v}")),
313 }
314 }
315}
316#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
317#[doc = "Default GUI language."]
318#[doc = ""]
319pub enum Language {
320 #[serde(rename = "ar")]
321 Ar,
322 #[serde(rename = "ca")]
323 Ca,
324 #[serde(rename = "da")]
325 Da,
326 #[serde(rename = "de")]
327 De,
328 #[serde(rename = "en")]
329 En,
330 #[serde(rename = "es")]
331 Es,
332 #[serde(rename = "eu")]
333 Eu,
334 #[serde(rename = "fa")]
335 Fa,
336 #[serde(rename = "fr")]
337 Fr,
338 #[serde(rename = "he")]
339 He,
340 #[serde(rename = "hr")]
341 Hr,
342 #[serde(rename = "it")]
343 It,
344 #[serde(rename = "ja")]
345 Ja,
346 #[serde(rename = "ka")]
347 Ka,
348 #[serde(rename = "kr")]
349 Kr,
350 #[serde(rename = "nb")]
351 Nb,
352 #[serde(rename = "nl")]
353 Nl,
354 #[serde(rename = "nn")]
355 Nn,
356 #[serde(rename = "pl")]
357 Pl,
358 #[serde(rename = "pt_BR")]
359 PtBR,
360 #[serde(rename = "ru")]
361 Ru,
362 #[serde(rename = "sl")]
363 Sl,
364 #[serde(rename = "sv")]
365 Sv,
366 #[serde(rename = "tr")]
367 Tr,
368 #[serde(rename = "ukr")]
369 Ukr,
370 #[serde(rename = "zh_CN")]
371 ZhCN,
372 #[serde(rename = "zh_TW")]
373 ZhTW,
374}
375impl TryFrom<&str> for Language {
376 type Error = String;
377 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
378 match value {
379 "ar" => Ok(Self::Ar),
380 "ca" => Ok(Self::Ca),
381 "da" => Ok(Self::Da),
382 "de" => Ok(Self::De),
383 "en" => Ok(Self::En),
384 "es" => Ok(Self::Es),
385 "eu" => Ok(Self::Eu),
386 "fa" => Ok(Self::Fa),
387 "fr" => Ok(Self::Fr),
388 "he" => Ok(Self::He),
389 "hr" => Ok(Self::Hr),
390 "it" => Ok(Self::It),
391 "ja" => Ok(Self::Ja),
392 "ka" => Ok(Self::Ka),
393 "kr" => Ok(Self::Kr),
394 "nb" => Ok(Self::Nb),
395 "nl" => Ok(Self::Nl),
396 "nn" => Ok(Self::Nn),
397 "pl" => Ok(Self::Pl),
398 "pt_BR" => Ok(Self::PtBR),
399 "ru" => Ok(Self::Ru),
400 "sl" => Ok(Self::Sl),
401 "sv" => Ok(Self::Sv),
402 "tr" => Ok(Self::Tr),
403 "ukr" => Ok(Self::Ukr),
404 "zh_CN" => Ok(Self::ZhCN),
405 "zh_TW" => Ok(Self::ZhTW),
406 v => Err(format!("Unknown variant {v}")),
407 }
408 }
409}
410#[derive(Debug, Clone, PartialEq, PartialOrd)]
411pub struct ConsentTextStr {
412 value: String,
413}
414impl crate::types::bounded_string::BoundedString for ConsentTextStr {
415 const MIN_LENGTH: Option<usize> = None::<usize>;
416 const MAX_LENGTH: Option<usize> = Some(65536usize);
417 const DEFAULT: Option<&'static str> = None::<&'static str>;
418 const PATTERN: Option<&'static str> = None::<&'static str>;
419 const TYPE_DESCRIPTION: &'static str = "a string with length at most 65536";
420 fn get_value(&self) -> &str {
421 &self.value
422 }
423 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
424 Self::validate(&value)?;
425 Ok(Self { value })
426 }
427}
428impl std::convert::TryFrom<String> for ConsentTextStr {
429 type Error = crate::types::bounded_string::BoundedStringError;
430 fn try_from(value: String) -> Result<Self, Self::Error> {
431 crate::types::bounded_string::BoundedString::new(value)
432 }
433}
434impl ::serde::Serialize for ConsentTextStr {
435 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
436 where
437 S: ::serde::Serializer,
438 {
439 crate::types::bounded_string::serialize_bounded_string(self, serializer)
440 }
441}
442impl<'de> ::serde::Deserialize<'de> for ConsentTextStr {
443 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
444 where
445 D: ::serde::Deserializer<'de>,
446 {
447 crate::types::bounded_string::deserialize_bounded_string(deserializer)
448 }
449}
450#[derive(Debug, Clone, PartialEq, PartialOrd)]
451pub struct DescriptionStr {
452 value: String,
453}
454impl crate::types::bounded_string::BoundedString for DescriptionStr {
455 const MIN_LENGTH: Option<usize> = None::<usize>;
456 const MAX_LENGTH: Option<usize> = Some(65536usize);
457 const DEFAULT: Option<&'static str> = None::<&'static str>;
458 const PATTERN: Option<&'static str> = None::<&'static str>;
459 const TYPE_DESCRIPTION: &'static str = "a string with length at most 65536";
460 fn get_value(&self) -> &str {
461 &self.value
462 }
463 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
464 Self::validate(&value)?;
465 Ok(Self { value })
466 }
467}
468impl std::convert::TryFrom<String> for DescriptionStr {
469 type Error = crate::types::bounded_string::BoundedStringError;
470 fn try_from(value: String) -> Result<Self, Self::Error> {
471 crate::types::bounded_string::BoundedString::new(value)
472 }
473}
474impl ::serde::Serialize for DescriptionStr {
475 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
476 where
477 S: ::serde::Serializer,
478 {
479 crate::types::bounded_string::serialize_bounded_string(self, serializer)
480 }
481}
482impl<'de> ::serde::Deserialize<'de> for DescriptionStr {
483 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
484 where
485 D: ::serde::Deserializer<'de>,
486 {
487 crate::types::bounded_string::deserialize_bounded_string(deserializer)
488 }
489}
490#[derive(Debug, Clone, PartialEq, PartialOrd)]
491pub struct HttpProxyStr {
492 value: String,
493}
494impl crate::types::bounded_string::BoundedString for HttpProxyStr {
495 const MIN_LENGTH: Option<usize> = None::<usize>;
496 const MAX_LENGTH: Option<usize> = None::<usize>;
497 const DEFAULT: Option<&'static str> = None::<&'static str>;
498 const PATTERN: Option<&'static str> = Some("http://.*");
499 const TYPE_DESCRIPTION: &'static str =
500 "a string with pattern r\"http://.*\" and no length constraints";
501 fn get_value(&self) -> &str {
502 &self.value
503 }
504 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
505 Self::validate(&value)?;
506 Ok(Self { value })
507 }
508}
509impl std::convert::TryFrom<String> for HttpProxyStr {
510 type Error = crate::types::bounded_string::BoundedStringError;
511 fn try_from(value: String) -> Result<Self, Self::Error> {
512 crate::types::bounded_string::BoundedString::new(value)
513 }
514}
515impl ::serde::Serialize for HttpProxyStr {
516 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
517 where
518 S: ::serde::Serializer,
519 {
520 crate::types::bounded_string::serialize_bounded_string(self, serializer)
521 }
522}
523impl<'de> ::serde::Deserialize<'de> for HttpProxyStr {
524 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
525 where
526 D: ::serde::Deserializer<'de>,
527 {
528 crate::types::bounded_string::deserialize_bounded_string(deserializer)
529 }
530}
531#[derive(Debug, Clone, PartialEq, PartialOrd)]
532pub struct RegisteredTagsStr {
533 value: String,
534}
535impl crate::types::bounded_string::BoundedString for RegisteredTagsStr {
536 const MIN_LENGTH: Option<usize> = None::<usize>;
537 const MAX_LENGTH: Option<usize> = None::<usize>;
538 const DEFAULT: Option<&'static str> = None::<&'static str>;
539 const PATTERN: Option<&'static str> =
540 Some("(?:(?^i:[a-z0-9_][a-z0-9_\\-\\+\\.]*);)*(?^i:[a-z0-9_][a-z0-9_\\-\\+\\.]*)");
541 const TYPE_DESCRIPTION: &'static str = "a string with pattern r\"(?:(?^i:[a-z0-9_][a-z0-9_\\-\\+\\.]*);)*(?^i:[a-z0-9_][a-z0-9_\\-\\+\\.]*)\" and no length constraints";
542 fn get_value(&self) -> &str {
543 &self.value
544 }
545 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
546 Self::validate(&value)?;
547 Ok(Self { value })
548 }
549}
550impl std::convert::TryFrom<String> for RegisteredTagsStr {
551 type Error = crate::types::bounded_string::BoundedStringError;
552 fn try_from(value: String) -> Result<Self, Self::Error> {
553 crate::types::bounded_string::BoundedString::new(value)
554 }
555}
556impl ::serde::Serialize for RegisteredTagsStr {
557 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
558 where
559 S: ::serde::Serializer,
560 {
561 crate::types::bounded_string::serialize_bounded_string(self, serializer)
562 }
563}
564impl<'de> ::serde::Deserialize<'de> for RegisteredTagsStr {
565 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
566 where
567 D: ::serde::Deserializer<'de>,
568 {
569 crate::types::bounded_string::deserialize_bounded_string(deserializer)
570 }
571}