1#[derive(Debug, Clone)]
2pub struct IdClient<T> {
3 client: T,
4 path: String,
5}
6impl<T> IdClient<T>
7where
8 T: crate::client::Client,
9{
10 pub fn new(client: T, parent_path: &str, id: &str) -> Self {
11 Self {
12 client,
13 path: format!("{}/{}", parent_path, id),
14 }
15 }
16}
17impl<T> IdClient<T>
18where
19 T: crate::client::Client,
20{
21 #[doc = "Delete ACME plugin configuration."]
22 #[doc = ""]
23 #[doc = "Permission check: perm(\"/\", [\"Sys.Modify\"])"]
24 pub async fn delete(&self) -> Result<(), T::Error> {
25 let path = self.path.to_string();
26 self.client.delete(&path, &()).await
27 }
28}
29impl<T> IdClient<T>
30where
31 T: crate::client::Client,
32{
33 #[doc = "Get ACME plugin configuration."]
34 #[doc = ""]
35 #[doc = "Permission check: perm(\"/\", [\"Sys.Modify\"])"]
36 pub async fn get(&self) -> Result<GetOutput, T::Error> {
37 let path = self.path.to_string();
38 self.client.get(&path, &()).await
39 }
40}
41impl<T> IdClient<T>
42where
43 T: crate::client::Client,
44{
45 #[doc = "Update ACME plugin configuration."]
46 #[doc = ""]
47 #[doc = "Permission check: perm(\"/\", [\"Sys.Modify\"])"]
48 pub async fn put(&self, params: PutParams) -> Result<(), T::Error> {
49 let path = self.path.to_string();
50 self.client.put(&path, ¶ms).await
51 }
52}
53impl GetOutput {
54 pub fn new(plugin: String, ty: Type) -> Self {
55 Self {
56 plugin,
57 ty,
58 api: ::std::default::Default::default(),
59 data: ::std::default::Default::default(),
60 digest: ::std::default::Default::default(),
61 disable: ::std::default::Default::default(),
62 nodes: ::std::default::Default::default(),
63 validation_delay: ::std::default::Default::default(),
64 additional_properties: ::std::default::Default::default(),
65 }
66 }
67}
68#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
69pub struct GetOutput {
70 #[serde(skip_serializing_if = "Option::is_none", default)]
71 #[doc = "API plugin name"]
72 #[doc = ""]
73 pub api: Option<Api>,
74 #[serde(skip_serializing_if = "Option::is_none", default)]
75 #[doc = "DNS plugin data. (base64 encoded)"]
76 #[doc = ""]
77 pub data: Option<String>,
78 #[serde(skip_serializing_if = "Option::is_none", default)]
79 #[doc = "Prevent changes if current configuration file has a different digest. This can be used to prevent concurrent modifications."]
80 #[doc = ""]
81 pub digest: Option<DigestStr>,
82 #[serde(
83 serialize_with = "crate::types::serialize_bool_optional",
84 deserialize_with = "crate::types::deserialize_bool_optional"
85 )]
86 #[serde(skip_serializing_if = "Option::is_none", default)]
87 #[doc = "Flag to disable the config."]
88 #[doc = ""]
89 pub disable: Option<bool>,
90 #[serde(skip_serializing_if = "Option::is_none", default)]
91 #[doc = "List of cluster node names."]
92 #[doc = ""]
93 pub nodes: Option<String>,
94 #[doc = "Unique identifier for ACME plugin instance."]
95 #[doc = ""]
96 pub plugin: String,
97 #[serde(rename = "type")]
98 #[doc = "ACME challenge type."]
99 #[doc = ""]
100 pub ty: Type,
101 #[serde(rename = "validation-delay")]
102 #[serde(skip_serializing_if = "Option::is_none", default)]
103 #[doc = "Extra delay in seconds to wait before requesting validation. Allows to cope with a long TTL of DNS records."]
104 #[doc = ""]
105 pub validation_delay: Option<ValidationDelayInt>,
106 #[serde(
107 flatten,
108 default,
109 skip_serializing_if = "::std::collections::HashMap::is_empty"
110 )]
111 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
112}
113#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
114pub struct PutParams {
115 #[serde(skip_serializing_if = "Option::is_none", default)]
116 #[doc = "API plugin name"]
117 #[doc = ""]
118 pub api: Option<Api>,
119 #[serde(skip_serializing_if = "Option::is_none", default)]
120 #[doc = "DNS plugin data. (base64 encoded)"]
121 #[doc = ""]
122 pub data: Option<String>,
123 #[serde(skip_serializing_if = "Option::is_none", default)]
124 #[doc = "A list of settings you want to delete."]
125 #[doc = ""]
126 pub delete: Option<DeleteStr>,
127 #[serde(skip_serializing_if = "Option::is_none", default)]
128 #[doc = "Prevent changes if current configuration file has a different digest. This can be used to prevent concurrent modifications."]
129 #[doc = ""]
130 pub digest: Option<DigestStr>,
131 #[serde(
132 serialize_with = "crate::types::serialize_bool_optional",
133 deserialize_with = "crate::types::deserialize_bool_optional"
134 )]
135 #[serde(skip_serializing_if = "Option::is_none", default)]
136 #[doc = "Flag to disable the config."]
137 #[doc = ""]
138 pub disable: Option<bool>,
139 #[serde(skip_serializing_if = "Option::is_none", default)]
140 #[doc = "List of cluster node names."]
141 #[doc = ""]
142 pub nodes: Option<String>,
143 #[serde(rename = "validation-delay")]
144 #[serde(skip_serializing_if = "Option::is_none", default)]
145 #[doc = "Extra delay in seconds to wait before requesting validation. Allows to cope with a long TTL of DNS records."]
146 #[doc = ""]
147 pub validation_delay: Option<ValidationDelayInt>,
148 #[serde(
149 flatten,
150 default,
151 skip_serializing_if = "::std::collections::HashMap::is_empty"
152 )]
153 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
154}
155#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
156#[doc = "API plugin name"]
157#[doc = ""]
158pub enum Api {
159 #[serde(rename = "1984hosting")]
160 _1984hosting,
161 #[serde(rename = "acmedns")]
162 Acmedns,
163 #[serde(rename = "acmeproxy")]
164 Acmeproxy,
165 #[serde(rename = "active24")]
166 Active24,
167 #[serde(rename = "ad")]
168 Ad,
169 #[serde(rename = "ali")]
170 Ali,
171 #[serde(rename = "alviy")]
172 Alviy,
173 #[serde(rename = "anx")]
174 Anx,
175 #[serde(rename = "artfiles")]
176 Artfiles,
177 #[serde(rename = "arvan")]
178 Arvan,
179 #[serde(rename = "aurora")]
180 Aurora,
181 #[serde(rename = "autodns")]
182 Autodns,
183 #[serde(rename = "aws")]
184 Aws,
185 #[serde(rename = "azion")]
186 Azion,
187 #[serde(rename = "azure")]
188 Azure,
189 #[serde(rename = "beget")]
190 Beget,
191 #[serde(rename = "bookmyname")]
192 Bookmyname,
193 #[serde(rename = "bunny")]
194 Bunny,
195 #[serde(rename = "cf")]
196 Cf,
197 #[serde(rename = "clouddns")]
198 Clouddns,
199 #[serde(rename = "cloudns")]
200 Cloudns,
201 #[serde(rename = "cn")]
202 Cn,
203 #[serde(rename = "conoha")]
204 Conoha,
205 #[serde(rename = "constellix")]
206 Constellix,
207 #[serde(rename = "cpanel")]
208 Cpanel,
209 #[serde(rename = "curanet")]
210 Curanet,
211 #[serde(rename = "cyon")]
212 Cyon,
213 #[serde(rename = "da")]
214 Da,
215 #[serde(rename = "ddnss")]
216 Ddnss,
217 #[serde(rename = "desec")]
218 Desec,
219 #[serde(rename = "df")]
220 Df,
221 #[serde(rename = "dgon")]
222 Dgon,
223 #[serde(rename = "dnsexit")]
224 Dnsexit,
225 #[serde(rename = "dnshome")]
226 Dnshome,
227 #[serde(rename = "dnsimple")]
228 Dnsimple,
229 #[serde(rename = "dnsservices")]
230 Dnsservices,
231 #[serde(rename = "doapi")]
232 Doapi,
233 #[serde(rename = "domeneshop")]
234 Domeneshop,
235 #[serde(rename = "dp")]
236 Dp,
237 #[serde(rename = "dpi")]
238 Dpi,
239 #[serde(rename = "dreamhost")]
240 Dreamhost,
241 #[serde(rename = "duckdns")]
242 Duckdns,
243 #[serde(rename = "durabledns")]
244 Durabledns,
245 #[serde(rename = "dyn")]
246 Dyn,
247 #[serde(rename = "dynu")]
248 Dynu,
249 #[serde(rename = "dynv6")]
250 Dynv6,
251 #[serde(rename = "easydns")]
252 Easydns,
253 #[serde(rename = "edgecenter")]
254 Edgecenter,
255 #[serde(rename = "edgedns")]
256 Edgedns,
257 #[serde(rename = "euserv")]
258 Euserv,
259 #[serde(rename = "exoscale")]
260 Exoscale,
261 #[serde(rename = "fornex")]
262 Fornex,
263 #[serde(rename = "freedns")]
264 Freedns,
265 #[serde(rename = "freemyip")]
266 Freemyip,
267 #[serde(rename = "gandi_livedns")]
268 GandiLivedns,
269 #[serde(rename = "gcloud")]
270 Gcloud,
271 #[serde(rename = "gcore")]
272 Gcore,
273 #[serde(rename = "gd")]
274 Gd,
275 #[serde(rename = "geoscaling")]
276 Geoscaling,
277 #[serde(rename = "googledomains")]
278 Googledomains,
279 #[serde(rename = "he")]
280 He,
281 #[serde(rename = "he_ddns")]
282 HeDdns,
283 #[serde(rename = "hetzner")]
284 Hetzner,
285 #[serde(rename = "hexonet")]
286 Hexonet,
287 #[serde(rename = "hostingde")]
288 Hostingde,
289 #[serde(rename = "huaweicloud")]
290 Huaweicloud,
291 #[serde(rename = "infoblox")]
292 Infoblox,
293 #[serde(rename = "infomaniak")]
294 Infomaniak,
295 #[serde(rename = "internetbs")]
296 Internetbs,
297 #[serde(rename = "inwx")]
298 Inwx,
299 #[serde(rename = "ionos")]
300 Ionos,
301 #[serde(rename = "ionos_cloud")]
302 IonosCloud,
303 #[serde(rename = "ipv64")]
304 Ipv64,
305 #[serde(rename = "ispconfig")]
306 Ispconfig,
307 #[serde(rename = "jd")]
308 Jd,
309 #[serde(rename = "joker")]
310 Joker,
311 #[serde(rename = "kappernet")]
312 Kappernet,
313 #[serde(rename = "kas")]
314 Kas,
315 #[serde(rename = "kinghost")]
316 Kinghost,
317 #[serde(rename = "knot")]
318 Knot,
319 #[serde(rename = "la")]
320 La,
321 #[serde(rename = "leaseweb")]
322 Leaseweb,
323 #[serde(rename = "lexicon")]
324 Lexicon,
325 #[serde(rename = "limacity")]
326 Limacity,
327 #[serde(rename = "linode")]
328 Linode,
329 #[serde(rename = "linode_v4")]
330 LinodeV4,
331 #[serde(rename = "loopia")]
332 Loopia,
333 #[serde(rename = "lua")]
334 Lua,
335 #[serde(rename = "maradns")]
336 Maradns,
337 #[serde(rename = "me")]
338 Me,
339 #[serde(rename = "miab")]
340 Miab,
341 #[serde(rename = "mijnhost")]
342 Mijnhost,
343 #[serde(rename = "misaka")]
344 Misaka,
345 #[serde(rename = "myapi")]
346 Myapi,
347 #[serde(rename = "mydevil")]
348 Mydevil,
349 #[serde(rename = "mydnsjp")]
350 Mydnsjp,
351 #[serde(rename = "mythic_beasts")]
352 MythicBeasts,
353 #[serde(rename = "namecheap")]
354 Namecheap,
355 #[serde(rename = "namecom")]
356 Namecom,
357 #[serde(rename = "namesilo")]
358 Namesilo,
359 #[serde(rename = "nanelo")]
360 Nanelo,
361 #[serde(rename = "nederhost")]
362 Nederhost,
363 #[serde(rename = "neodigit")]
364 Neodigit,
365 #[serde(rename = "netcup")]
366 Netcup,
367 #[serde(rename = "netlify")]
368 Netlify,
369 #[serde(rename = "nic")]
370 Nic,
371 #[serde(rename = "njalla")]
372 Njalla,
373 #[serde(rename = "nm")]
374 Nm,
375 #[serde(rename = "nsd")]
376 Nsd,
377 #[serde(rename = "nsone")]
378 Nsone,
379 #[serde(rename = "nsupdate")]
380 Nsupdate,
381 #[serde(rename = "nw")]
382 Nw,
383 #[serde(rename = "oci")]
384 Oci,
385 #[serde(rename = "omglol")]
386 Omglol,
387 #[serde(rename = "one")]
388 One,
389 #[serde(rename = "online")]
390 Online,
391 #[serde(rename = "openprovider")]
392 Openprovider,
393 #[serde(rename = "openstack")]
394 Openstack,
395 #[serde(rename = "opnsense")]
396 Opnsense,
397 #[serde(rename = "ovh")]
398 Ovh,
399 #[serde(rename = "pdns")]
400 Pdns,
401 #[serde(rename = "pleskxml")]
402 Pleskxml,
403 #[serde(rename = "pointhq")]
404 Pointhq,
405 #[serde(rename = "porkbun")]
406 Porkbun,
407 #[serde(rename = "rackcorp")]
408 Rackcorp,
409 #[serde(rename = "rackspace")]
410 Rackspace,
411 #[serde(rename = "rage4")]
412 Rage4,
413 #[serde(rename = "rcode0")]
414 Rcode0,
415 #[serde(rename = "regru")]
416 Regru,
417 #[serde(rename = "scaleway")]
418 Scaleway,
419 #[serde(rename = "schlundtech")]
420 Schlundtech,
421 #[serde(rename = "selectel")]
422 Selectel,
423 #[serde(rename = "selfhost")]
424 Selfhost,
425 #[serde(rename = "servercow")]
426 Servercow,
427 #[serde(rename = "simply")]
428 Simply,
429 #[serde(rename = "technitium")]
430 Technitium,
431 #[serde(rename = "tele3")]
432 Tele3,
433 #[serde(rename = "tencent")]
434 Tencent,
435 #[serde(rename = "timeweb")]
436 Timeweb,
437 #[serde(rename = "transip")]
438 Transip,
439 #[serde(rename = "udr")]
440 Udr,
441 #[serde(rename = "ultra")]
442 Ultra,
443 #[serde(rename = "unoeuro")]
444 Unoeuro,
445 #[serde(rename = "variomedia")]
446 Variomedia,
447 #[serde(rename = "veesp")]
448 Veesp,
449 #[serde(rename = "vercel")]
450 Vercel,
451 #[serde(rename = "vscale")]
452 Vscale,
453 #[serde(rename = "vultr")]
454 Vultr,
455 #[serde(rename = "websupport")]
456 Websupport,
457 #[serde(rename = "west_cn")]
458 WestCn,
459 #[serde(rename = "world4you")]
460 World4you,
461 #[serde(rename = "yandex360")]
462 Yandex360,
463 #[serde(rename = "yc")]
464 Yc,
465 #[serde(rename = "zilore")]
466 Zilore,
467 #[serde(rename = "zone")]
468 Zone,
469 #[serde(rename = "zoneedit")]
470 Zoneedit,
471 #[serde(rename = "zonomi")]
472 Zonomi,
473}
474impl TryFrom<&str> for Api {
475 type Error = String;
476 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
477 match value {
478 "1984hosting" => Ok(Self::_1984hosting),
479 "acmedns" => Ok(Self::Acmedns),
480 "acmeproxy" => Ok(Self::Acmeproxy),
481 "active24" => Ok(Self::Active24),
482 "ad" => Ok(Self::Ad),
483 "ali" => Ok(Self::Ali),
484 "alviy" => Ok(Self::Alviy),
485 "anx" => Ok(Self::Anx),
486 "artfiles" => Ok(Self::Artfiles),
487 "arvan" => Ok(Self::Arvan),
488 "aurora" => Ok(Self::Aurora),
489 "autodns" => Ok(Self::Autodns),
490 "aws" => Ok(Self::Aws),
491 "azion" => Ok(Self::Azion),
492 "azure" => Ok(Self::Azure),
493 "beget" => Ok(Self::Beget),
494 "bookmyname" => Ok(Self::Bookmyname),
495 "bunny" => Ok(Self::Bunny),
496 "cf" => Ok(Self::Cf),
497 "clouddns" => Ok(Self::Clouddns),
498 "cloudns" => Ok(Self::Cloudns),
499 "cn" => Ok(Self::Cn),
500 "conoha" => Ok(Self::Conoha),
501 "constellix" => Ok(Self::Constellix),
502 "cpanel" => Ok(Self::Cpanel),
503 "curanet" => Ok(Self::Curanet),
504 "cyon" => Ok(Self::Cyon),
505 "da" => Ok(Self::Da),
506 "ddnss" => Ok(Self::Ddnss),
507 "desec" => Ok(Self::Desec),
508 "df" => Ok(Self::Df),
509 "dgon" => Ok(Self::Dgon),
510 "dnsexit" => Ok(Self::Dnsexit),
511 "dnshome" => Ok(Self::Dnshome),
512 "dnsimple" => Ok(Self::Dnsimple),
513 "dnsservices" => Ok(Self::Dnsservices),
514 "doapi" => Ok(Self::Doapi),
515 "domeneshop" => Ok(Self::Domeneshop),
516 "dp" => Ok(Self::Dp),
517 "dpi" => Ok(Self::Dpi),
518 "dreamhost" => Ok(Self::Dreamhost),
519 "duckdns" => Ok(Self::Duckdns),
520 "durabledns" => Ok(Self::Durabledns),
521 "dyn" => Ok(Self::Dyn),
522 "dynu" => Ok(Self::Dynu),
523 "dynv6" => Ok(Self::Dynv6),
524 "easydns" => Ok(Self::Easydns),
525 "edgecenter" => Ok(Self::Edgecenter),
526 "edgedns" => Ok(Self::Edgedns),
527 "euserv" => Ok(Self::Euserv),
528 "exoscale" => Ok(Self::Exoscale),
529 "fornex" => Ok(Self::Fornex),
530 "freedns" => Ok(Self::Freedns),
531 "freemyip" => Ok(Self::Freemyip),
532 "gandi_livedns" => Ok(Self::GandiLivedns),
533 "gcloud" => Ok(Self::Gcloud),
534 "gcore" => Ok(Self::Gcore),
535 "gd" => Ok(Self::Gd),
536 "geoscaling" => Ok(Self::Geoscaling),
537 "googledomains" => Ok(Self::Googledomains),
538 "he" => Ok(Self::He),
539 "he_ddns" => Ok(Self::HeDdns),
540 "hetzner" => Ok(Self::Hetzner),
541 "hexonet" => Ok(Self::Hexonet),
542 "hostingde" => Ok(Self::Hostingde),
543 "huaweicloud" => Ok(Self::Huaweicloud),
544 "infoblox" => Ok(Self::Infoblox),
545 "infomaniak" => Ok(Self::Infomaniak),
546 "internetbs" => Ok(Self::Internetbs),
547 "inwx" => Ok(Self::Inwx),
548 "ionos" => Ok(Self::Ionos),
549 "ionos_cloud" => Ok(Self::IonosCloud),
550 "ipv64" => Ok(Self::Ipv64),
551 "ispconfig" => Ok(Self::Ispconfig),
552 "jd" => Ok(Self::Jd),
553 "joker" => Ok(Self::Joker),
554 "kappernet" => Ok(Self::Kappernet),
555 "kas" => Ok(Self::Kas),
556 "kinghost" => Ok(Self::Kinghost),
557 "knot" => Ok(Self::Knot),
558 "la" => Ok(Self::La),
559 "leaseweb" => Ok(Self::Leaseweb),
560 "lexicon" => Ok(Self::Lexicon),
561 "limacity" => Ok(Self::Limacity),
562 "linode" => Ok(Self::Linode),
563 "linode_v4" => Ok(Self::LinodeV4),
564 "loopia" => Ok(Self::Loopia),
565 "lua" => Ok(Self::Lua),
566 "maradns" => Ok(Self::Maradns),
567 "me" => Ok(Self::Me),
568 "miab" => Ok(Self::Miab),
569 "mijnhost" => Ok(Self::Mijnhost),
570 "misaka" => Ok(Self::Misaka),
571 "myapi" => Ok(Self::Myapi),
572 "mydevil" => Ok(Self::Mydevil),
573 "mydnsjp" => Ok(Self::Mydnsjp),
574 "mythic_beasts" => Ok(Self::MythicBeasts),
575 "namecheap" => Ok(Self::Namecheap),
576 "namecom" => Ok(Self::Namecom),
577 "namesilo" => Ok(Self::Namesilo),
578 "nanelo" => Ok(Self::Nanelo),
579 "nederhost" => Ok(Self::Nederhost),
580 "neodigit" => Ok(Self::Neodigit),
581 "netcup" => Ok(Self::Netcup),
582 "netlify" => Ok(Self::Netlify),
583 "nic" => Ok(Self::Nic),
584 "njalla" => Ok(Self::Njalla),
585 "nm" => Ok(Self::Nm),
586 "nsd" => Ok(Self::Nsd),
587 "nsone" => Ok(Self::Nsone),
588 "nsupdate" => Ok(Self::Nsupdate),
589 "nw" => Ok(Self::Nw),
590 "oci" => Ok(Self::Oci),
591 "omglol" => Ok(Self::Omglol),
592 "one" => Ok(Self::One),
593 "online" => Ok(Self::Online),
594 "openprovider" => Ok(Self::Openprovider),
595 "openstack" => Ok(Self::Openstack),
596 "opnsense" => Ok(Self::Opnsense),
597 "ovh" => Ok(Self::Ovh),
598 "pdns" => Ok(Self::Pdns),
599 "pleskxml" => Ok(Self::Pleskxml),
600 "pointhq" => Ok(Self::Pointhq),
601 "porkbun" => Ok(Self::Porkbun),
602 "rackcorp" => Ok(Self::Rackcorp),
603 "rackspace" => Ok(Self::Rackspace),
604 "rage4" => Ok(Self::Rage4),
605 "rcode0" => Ok(Self::Rcode0),
606 "regru" => Ok(Self::Regru),
607 "scaleway" => Ok(Self::Scaleway),
608 "schlundtech" => Ok(Self::Schlundtech),
609 "selectel" => Ok(Self::Selectel),
610 "selfhost" => Ok(Self::Selfhost),
611 "servercow" => Ok(Self::Servercow),
612 "simply" => Ok(Self::Simply),
613 "technitium" => Ok(Self::Technitium),
614 "tele3" => Ok(Self::Tele3),
615 "tencent" => Ok(Self::Tencent),
616 "timeweb" => Ok(Self::Timeweb),
617 "transip" => Ok(Self::Transip),
618 "udr" => Ok(Self::Udr),
619 "ultra" => Ok(Self::Ultra),
620 "unoeuro" => Ok(Self::Unoeuro),
621 "variomedia" => Ok(Self::Variomedia),
622 "veesp" => Ok(Self::Veesp),
623 "vercel" => Ok(Self::Vercel),
624 "vscale" => Ok(Self::Vscale),
625 "vultr" => Ok(Self::Vultr),
626 "websupport" => Ok(Self::Websupport),
627 "west_cn" => Ok(Self::WestCn),
628 "world4you" => Ok(Self::World4you),
629 "yandex360" => Ok(Self::Yandex360),
630 "yc" => Ok(Self::Yc),
631 "zilore" => Ok(Self::Zilore),
632 "zone" => Ok(Self::Zone),
633 "zoneedit" => Ok(Self::Zoneedit),
634 "zonomi" => Ok(Self::Zonomi),
635 v => Err(format!("Unknown variant {v}")),
636 }
637 }
638}
639#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
640#[doc = "ACME challenge type."]
641#[doc = ""]
642pub enum Type {
643 #[serde(rename = "dns")]
644 Dns,
645 #[serde(rename = "standalone")]
646 Standalone,
647}
648impl TryFrom<&str> for Type {
649 type Error = String;
650 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
651 match value {
652 "dns" => Ok(Self::Dns),
653 "standalone" => Ok(Self::Standalone),
654 v => Err(format!("Unknown variant {v}")),
655 }
656 }
657}
658#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
659pub struct ValidationDelayInt(i128);
660impl crate::types::bounded_integer::BoundedInteger for ValidationDelayInt {
661 const MIN: Option<i128> = Some(0i128);
662 const MAX: Option<i128> = Some(172800i128);
663 const DEFAULT: Option<i128> = Some(30i128);
664 const TYPE_DESCRIPTION: &'static str = "an integer between 0 and 172800";
665 fn get(&self) -> i128 {
666 self.0
667 }
668 fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
669 Self::validate(value)?;
670 Ok(Self(value))
671 }
672}
673impl std::convert::TryFrom<i128> for ValidationDelayInt {
674 type Error = crate::types::bounded_integer::BoundedIntegerError;
675 fn try_from(value: i128) -> Result<Self, Self::Error> {
676 crate::types::bounded_integer::BoundedInteger::new(value)
677 }
678}
679impl ::serde::Serialize for ValidationDelayInt {
680 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
681 where
682 S: ::serde::Serializer,
683 {
684 crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
685 }
686}
687impl<'de> ::serde::Deserialize<'de> for ValidationDelayInt {
688 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
689 where
690 D: ::serde::Deserializer<'de>,
691 {
692 crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
693 }
694}
695#[derive(Debug, Clone, PartialEq, PartialOrd)]
696pub struct DeleteStr {
697 value: String,
698}
699impl crate::types::bounded_string::BoundedString for DeleteStr {
700 const MIN_LENGTH: Option<usize> = None::<usize>;
701 const MAX_LENGTH: Option<usize> = Some(4096usize);
702 const DEFAULT: Option<&'static str> = None::<&'static str>;
703 const PATTERN: Option<&'static str> = None::<&'static str>;
704 const TYPE_DESCRIPTION: &'static str = "a string with length at most 4096";
705 fn get_value(&self) -> &str {
706 &self.value
707 }
708 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
709 Self::validate(&value)?;
710 Ok(Self { value })
711 }
712}
713impl std::convert::TryFrom<String> for DeleteStr {
714 type Error = crate::types::bounded_string::BoundedStringError;
715 fn try_from(value: String) -> Result<Self, Self::Error> {
716 crate::types::bounded_string::BoundedString::new(value)
717 }
718}
719impl ::serde::Serialize for DeleteStr {
720 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
721 where
722 S: ::serde::Serializer,
723 {
724 crate::types::bounded_string::serialize_bounded_string(self, serializer)
725 }
726}
727impl<'de> ::serde::Deserialize<'de> for DeleteStr {
728 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
729 where
730 D: ::serde::Deserializer<'de>,
731 {
732 crate::types::bounded_string::deserialize_bounded_string(deserializer)
733 }
734}
735#[derive(Debug, Clone, PartialEq, PartialOrd)]
736pub struct DigestStr {
737 value: String,
738}
739impl crate::types::bounded_string::BoundedString for DigestStr {
740 const MIN_LENGTH: Option<usize> = None::<usize>;
741 const MAX_LENGTH: Option<usize> = Some(64usize);
742 const DEFAULT: Option<&'static str> = None::<&'static str>;
743 const PATTERN: Option<&'static str> = None::<&'static str>;
744 const TYPE_DESCRIPTION: &'static str = "a string with length at most 64";
745 fn get_value(&self) -> &str {
746 &self.value
747 }
748 fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
749 Self::validate(&value)?;
750 Ok(Self { value })
751 }
752}
753impl std::convert::TryFrom<String> for DigestStr {
754 type Error = crate::types::bounded_string::BoundedStringError;
755 fn try_from(value: String) -> Result<Self, Self::Error> {
756 crate::types::bounded_string::BoundedString::new(value)
757 }
758}
759impl ::serde::Serialize for DigestStr {
760 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
761 where
762 S: ::serde::Serializer,
763 {
764 crate::types::bounded_string::serialize_bounded_string(self, serializer)
765 }
766}
767impl<'de> ::serde::Deserialize<'de> for DigestStr {
768 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
769 where
770 D: ::serde::Deserializer<'de>,
771 {
772 crate::types::bounded_string::deserialize_bounded_string(deserializer)
773 }
774}