Skip to main content

dns_update/
update.rs

1/*
2 * Copyright Stalwart Labs LLC See the COPYING
3 * file at the top-level directory of this distribution.
4 *
5 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 * https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 * <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
8 * option. This file may not be copied, modified, or distributed
9 * except according to those terms.
10 */
11
12#[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
13use crate::providers::oraclecloud::{OracleCloudConfig, OracleCloudProvider};
14#[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
15use crate::providers::ovh::{OvhEndpoint, OvhProvider};
16
17#[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
18use crate::providers::transip::TransipProvider;
19
20#[cfg(feature = "test_provider")]
21use crate::providers::{in_memory::InMemoryProvider, pebble::PebbleProvider};
22
23#[cfg(feature = "test_provider")]
24use crate::NamedDnsRecord;
25
26#[cfg(feature = "test_provider")]
27use std::sync::{Arc, Mutex};
28
29use crate::{
30    DnsRecord, DnsRecordType, DnsUpdater, IntoFqdn, TsigAlgorithm,
31    providers::{
32        alidns::AlidnsProvider,
33        arvancloud::ArvanCloudProvider,
34        autodns::AutodnsProvider,
35        azuredns::{AzureDnsConfig, AzureDnsProvider},
36        baiducloud::BaiduCloudProvider,
37        bluecatv2::{BluecatV2Config, BluecatV2Provider},
38        bunny::BunnyProvider,
39        cloudflare::CloudflareProvider,
40        cloudns::ClouDnsProvider,
41        constellix::ConstellixProvider,
42        cpanel::CpanelProvider,
43        ddnss::DdnssProvider,
44        desec::DesecProvider,
45        digitalocean::DigitalOceanProvider,
46        dnsimple::DNSimpleProvider,
47        dnsmadeeasy::DnsMadeEasyProvider,
48        domeneshop::DomeneshopProvider,
49        dreamhost::DreamhostProvider,
50        duckdns::DuckDnsProvider,
51        dynu::DynuProvider,
52        easydns::EasyDnsProvider,
53        edgedns::{EdgeDnsConfig, EdgeDnsProvider},
54        exoscale::ExoscaleProvider,
55        freemyip::FreeMyIpProvider,
56        gandiv5::GandiV5Provider,
57        gcore::GcoreProvider,
58        glesys::GlesysProvider,
59        godaddy::GodaddyProvider,
60        hetzner::HetznerProvider,
61        hostingde::HostingDeProvider,
62        hostinger::HostingerProvider,
63        huaweicloud::HuaweiCloudProvider,
64        hurricane::HurricaneProvider,
65        ibmcloud::IbmCloudProvider,
66        infoblox::{InfobloxConfig, InfobloxProvider},
67        infomaniak::InfomaniakProvider,
68        inwx::InwxProvider,
69        ionos::IonosProvider,
70        ipv64::Ipv64Provider,
71        joker::{JokerAuth, JokerProvider},
72        lightsail::{LightsailConfig, LightsailProvider},
73        linode::LinodeProvider,
74        luadns::LuaDnsProvider,
75        mythicbeasts::MythicBeastsProvider,
76        namecheap::NamecheapProvider,
77        namedotcom::NameDotComProvider,
78        namesilo::NameSiloProvider,
79        netcup::NetcupProvider,
80        netlify::NetlifyProvider,
81        nifcloud::NifcloudProvider,
82        ns1::Ns1Provider,
83        plesk::PleskProvider,
84        porkbun::PorkBunProvider,
85        rfc2136::{DnsAddress, Rfc2136Provider},
86        route53::Route53Provider,
87        safedns::SafeDnsProvider,
88        scaleway::ScalewayProvider,
89        spaceship::SpaceshipProvider,
90        tencentcloud::TencentCloudProvider,
91        ultradns::UltraDnsProvider,
92        vercel::VercelProvider,
93        vultr::VultrProvider,
94        websupport::WebSupportProvider,
95    },
96};
97use std::collections::HashMap;
98use std::time::Duration;
99
100impl DnsUpdater {
101    /// Create a new DNS updater using the RFC 2136 protocol and TSIG authentication.
102    pub fn new_rfc2136_tsig(
103        addr: impl TryInto<DnsAddress>,
104        key_name: impl AsRef<str>,
105        key: impl Into<Vec<u8>>,
106        algorithm: TsigAlgorithm,
107    ) -> crate::Result<Self> {
108        Ok(DnsUpdater::Rfc2136(Rfc2136Provider::new_tsig(
109            addr,
110            key_name,
111            key,
112            algorithm.into(),
113        )?))
114    }
115
116    /// Create a new DNS updater using the Cloudflare API.
117    pub fn new_cloudflare(
118        secret: impl AsRef<str>,
119        timeout: Option<Duration>,
120    ) -> crate::Result<Self> {
121        Ok(DnsUpdater::Cloudflare(CloudflareProvider::new(
122            secret, timeout,
123        )?))
124    }
125
126    /// Create a new DNS updater using the DigitalOcean API.
127    pub fn new_digitalocean(
128        auth_token: impl AsRef<str>,
129        timeout: Option<Duration>,
130    ) -> crate::Result<Self> {
131        Ok(DnsUpdater::DigitalOcean(DigitalOceanProvider::new(
132            auth_token, timeout,
133        )))
134    }
135
136    /// Create a new DNS updater using the Desec.io API.
137    pub fn new_desec(
138        auth_token: impl AsRef<str>,
139        timeout: Option<Duration>,
140    ) -> crate::Result<Self> {
141        Ok(DnsUpdater::Desec(DesecProvider::new(auth_token, timeout)))
142    }
143
144    /// Create a new DNS updater using the Constellix API.
145    pub fn new_constellix(
146        api_key: impl AsRef<str>,
147        secret_key: impl AsRef<str>,
148        timeout: Option<Duration>,
149    ) -> crate::Result<Self> {
150        Ok(DnsUpdater::Constellix(ConstellixProvider::new(
151            api_key, secret_key, timeout,
152        )?))
153    }
154
155    /// Create a new DNS updater using the DNSMadeEasy API.
156    pub fn new_dnsmadeeasy(
157        api_key: impl AsRef<str>,
158        api_secret: impl AsRef<str>,
159        timeout: Option<Duration>,
160    ) -> crate::Result<Self> {
161        Ok(DnsUpdater::DnsMadeEasy(DnsMadeEasyProvider::new(
162            api_key, api_secret, timeout,
163        )?))
164    }
165
166    /// Create a new DNS updater using the OVH API.
167    #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
168    pub fn new_ovh(
169        application_key: impl AsRef<str>,
170        application_secret: impl AsRef<str>,
171        consumer_key: impl AsRef<str>,
172        endpoint: OvhEndpoint,
173        timeout: Option<Duration>,
174    ) -> crate::Result<Self> {
175        Ok(DnsUpdater::Ovh(OvhProvider::new(
176            application_key,
177            application_secret,
178            consumer_key,
179            endpoint,
180            timeout,
181        )?))
182    }
183
184    /// Create a new DNS updater using the Oracle Cloud Infrastructure DNS API.
185    #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
186    pub fn new_oraclecloud(config: OracleCloudConfig) -> crate::Result<Self> {
187        Ok(DnsUpdater::OracleCloud(OracleCloudProvider::new(config)?))
188    }
189
190    /// Create a new DNS updater using the Bunny API.
191    pub fn new_bunny(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
192        Ok(DnsUpdater::Bunny(BunnyProvider::new(api_key, timeout)?))
193    }
194
195    /// Create a new DNS updater using the Linode API.
196    pub fn new_linode(
197        auth_token: impl AsRef<str>,
198        timeout: Option<Duration>,
199    ) -> crate::Result<Self> {
200        Ok(DnsUpdater::Linode(LinodeProvider::new(auth_token, timeout)))
201    }
202
203    /// Create a new DNS updater using the Porkbun API.
204    pub fn new_porkbun(
205        api_key: impl AsRef<str>,
206        secret_api_key: impl AsRef<str>,
207        timeout: Option<Duration>,
208    ) -> crate::Result<Self> {
209        Ok(DnsUpdater::Porkbun(PorkBunProvider::new(
210            api_key,
211            secret_api_key,
212            timeout,
213        )))
214    }
215
216    /// Create a new DNS updater using the Exoscale DNS API.
217    pub fn new_exoscale(
218        api_key: impl AsRef<str>,
219        api_secret: impl AsRef<str>,
220        timeout: Option<Duration>,
221    ) -> crate::Result<Self> {
222        Ok(DnsUpdater::Exoscale(ExoscaleProvider::new(
223            api_key, api_secret, timeout,
224        )?))
225    }
226
227    /// Create a new DNS updater using the Nifcloud DNS API.
228    pub fn new_nifcloud(
229        access_key: impl AsRef<str>,
230        secret_key: impl AsRef<str>,
231        timeout: Option<Duration>,
232    ) -> crate::Result<Self> {
233        Ok(DnsUpdater::Nifcloud(NifcloudProvider::new(
234            access_key, secret_key, timeout,
235        )?))
236    }
237
238    /// Create a new DNS updater using the WebSupport API.
239    pub fn new_websupport(
240        api_key: impl AsRef<str>,
241        secret: impl AsRef<str>,
242        timeout: Option<Duration>,
243    ) -> crate::Result<Self> {
244        Ok(DnsUpdater::WebSupport(WebSupportProvider::new(
245            api_key, secret, timeout,
246        )?))
247    }
248
249    /// Create a new DNS updater using the Spaceship API.
250    pub fn new_spaceship(
251        api_key: impl AsRef<str>,
252        api_secret: impl AsRef<str>,
253        timeout: Option<Duration>,
254    ) -> crate::Result<Self> {
255        Ok(DnsUpdater::Spaceship(SpaceshipProvider::new(
256            api_key, api_secret, timeout,
257        )))
258    }
259
260    /// Create a new DNS updater using the DNSimple API.
261    pub fn new_dnsimple(
262        auth_token: impl AsRef<str>,
263        account_id: impl AsRef<str>,
264        timeout: Option<Duration>,
265    ) -> crate::Result<Self> {
266        Ok(DnsUpdater::DNSimple(DNSimpleProvider::new(
267            auth_token, account_id, timeout,
268        )))
269    }
270
271    /// Create a new DNS updater using the Gandi LiveDNS API (v5).
272    pub fn new_gandiv5(
273        personal_access_token: impl AsRef<str>,
274        timeout: Option<Duration>,
275    ) -> crate::Result<Self> {
276        Ok(DnsUpdater::GandiV5(GandiV5Provider::new(
277            personal_access_token,
278            timeout,
279        )?))
280    }
281
282    /// Create a new DNS updater using the GoDaddy API.
283    pub fn new_godaddy(
284        api_key: impl AsRef<str>,
285        api_secret: impl AsRef<str>,
286        timeout: Option<Duration>,
287    ) -> crate::Result<Self> {
288        Ok(DnsUpdater::Godaddy(GodaddyProvider::new(
289            api_key, api_secret, timeout,
290        )?))
291    }
292
293    /// Create a new DNS updater using the Hetzner Cloud DNS (v1) API.
294    pub fn new_hetzner(
295        api_token: impl AsRef<str>,
296        timeout: Option<Duration>,
297    ) -> crate::Result<Self> {
298        Ok(DnsUpdater::Hetzner(HetznerProvider::new(
299            api_token, timeout,
300        )?))
301    }
302
303    /// Create a new DNS updater using the Name.com v4 API.
304    pub fn new_namedotcom(
305        username: impl AsRef<str>,
306        api_token: impl AsRef<str>,
307        timeout: Option<Duration>,
308    ) -> crate::Result<Self> {
309        Ok(DnsUpdater::NameDotCom(NameDotComProvider::new(
310            username, api_token, timeout,
311        )?))
312    }
313
314    /// Create a new DNS updater using the NameSilo API.
315    pub fn new_namesilo(
316        api_key: impl AsRef<str>,
317        timeout: Option<Duration>,
318    ) -> crate::Result<Self> {
319        Ok(DnsUpdater::NameSilo(NameSiloProvider::new(
320            api_key, timeout,
321        )?))
322    }
323
324    /// Create a new DNS updater using the DuckDNS API.
325    pub fn new_duckdns(token: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
326        Ok(DnsUpdater::DuckDns(DuckDnsProvider::new(token, timeout)?))
327    }
328
329    /// Create a new DNS updater using the freemyip.com API.
330    pub fn new_freemyip(token: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
331        Ok(DnsUpdater::FreeMyIp(FreeMyIpProvider::new(token, timeout)?))
332    }
333
334    /// Create a new DNS updater using the IPv64 API.
335    pub fn new_ipv64(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
336        Ok(DnsUpdater::Ipv64(Ipv64Provider::new(api_key, timeout)?))
337    }
338
339    /// Create a new DNS updater using the DDNSS.de API.
340    pub fn new_ddnss(key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
341        Ok(DnsUpdater::Ddnss(DdnssProvider::new(key, timeout)?))
342    }
343
344    /// Create a new DNS updater using the Dynu API.
345    pub fn new_dynu(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
346        Ok(DnsUpdater::Dynu(DynuProvider::new(api_key, timeout)?))
347    }
348
349    /// Create a new DNS updater using the Google Cloud DNS API.
350    pub fn new_google_cloud_dns(
351        config: crate::providers::google_cloud_dns::GoogleCloudDnsConfig,
352    ) -> crate::Result<Self> {
353        Ok(DnsUpdater::GoogleCloudDns(
354            crate::providers::google_cloud_dns::GoogleCloudDnsProvider::new(config)?,
355        ))
356    }
357
358    /// Create a new DNS updater using the Route53 API.
359    pub fn new_route53(config: crate::providers::route53::Route53Config) -> crate::Result<Self> {
360        Ok(DnsUpdater::Route53(Route53Provider::new(config)))
361    }
362
363    /// Create a new DNS updater using the Vultr API.
364    pub fn new_vultr(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
365        Ok(DnsUpdater::Vultr(VultrProvider::new(api_key, timeout)))
366    }
367
368    /// Create a new DNS updater using the Scaleway Domains API.
369    pub fn new_scaleway(
370        api_token: impl AsRef<str>,
371        timeout: Option<Duration>,
372    ) -> crate::Result<Self> {
373        Ok(DnsUpdater::Scaleway(ScalewayProvider::new(
374            api_token, timeout,
375        )))
376    }
377
378    /// Create a new DNS updater using the Gcore DNS API.
379    pub fn new_gcore(api_token: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
380        Ok(DnsUpdater::Gcore(GcoreProvider::new(api_token, timeout)))
381    }
382
383    /// Create a new DNS updater using the Vercel API.
384    pub fn new_vercel(
385        auth_token: impl AsRef<str>,
386        team_id: Option<impl AsRef<str>>,
387        timeout: Option<Duration>,
388    ) -> crate::Result<Self> {
389        Ok(DnsUpdater::Vercel(VercelProvider::new(
390            auth_token, team_id, timeout,
391        )))
392    }
393
394    /// Create a new DNS updater using the IONOS DNS API.
395    pub fn new_ionos(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
396        Ok(DnsUpdater::Ionos(IonosProvider::new(api_key, timeout)))
397    }
398
399    /// Create a new DNS updater using the hosting.de API.
400    pub fn new_hostingde(
401        api_key: impl AsRef<str>,
402        timeout: Option<Duration>,
403    ) -> crate::Result<Self> {
404        Ok(DnsUpdater::HostingDe(HostingDeProvider::new(
405            api_key, timeout,
406        )))
407    }
408
409    /// Create a new DNS updater using the Domeneshop API.
410    pub fn new_domeneshop(
411        api_token: impl AsRef<str>,
412        api_secret: impl AsRef<str>,
413        timeout: Option<Duration>,
414    ) -> crate::Result<Self> {
415        Ok(DnsUpdater::Domeneshop(DomeneshopProvider::new(
416            api_token, api_secret, timeout,
417        )))
418    }
419
420    /// Create a new DNS updater using the ANS SafeDNS API.
421    pub fn new_safedns(
422        auth_token: impl AsRef<str>,
423        timeout: Option<Duration>,
424    ) -> crate::Result<Self> {
425        Ok(DnsUpdater::Safedns(SafeDnsProvider::new(
426            auth_token, timeout,
427        )))
428    }
429
430    /// Create a new DNS updater using the ArvanCloud API.
431    pub fn new_arvancloud(
432        api_key: impl AsRef<str>,
433        timeout: Option<Duration>,
434    ) -> crate::Result<Self> {
435        Ok(DnsUpdater::ArvanCloud(ArvanCloudProvider::new(
436            api_key, timeout,
437        )))
438    }
439
440    /// Create a new DNS updater using the Infomaniak API.
441    pub fn new_infomaniak(
442        access_token: impl AsRef<str>,
443        timeout: Option<Duration>,
444    ) -> crate::Result<Self> {
445        Ok(DnsUpdater::Infomaniak(InfomaniakProvider::new(
446            access_token,
447            timeout,
448        )))
449    }
450
451    /// Create a new DNS updater using the NS1 API.
452    pub fn new_ns1(api_key: impl AsRef<str>, timeout: Option<Duration>) -> crate::Result<Self> {
453        Ok(DnsUpdater::Ns1(Ns1Provider::new(api_key, timeout)))
454    }
455
456    /// Create a new DNS updater using the LuaDNS API.
457    pub fn new_luadns(
458        api_username: impl AsRef<str>,
459        api_token: impl AsRef<str>,
460        timeout: Option<Duration>,
461    ) -> crate::Result<Self> {
462        Ok(DnsUpdater::LuaDns(LuaDnsProvider::new(
463            api_username,
464            api_token,
465            timeout,
466        )))
467    }
468
469    /// Create a new DNS updater using the Netcup CCP API.
470    pub fn new_netcup(
471        customer_number: impl AsRef<str>,
472        api_key: impl AsRef<str>,
473        api_password: impl AsRef<str>,
474        timeout: Option<Duration>,
475    ) -> crate::Result<Self> {
476        Ok(DnsUpdater::Netcup(NetcupProvider::new(
477            customer_number,
478            api_key,
479            api_password,
480            timeout,
481        )))
482    }
483
484    /// Create a new DNS updater using the Netlify API.
485    pub fn new_netlify(
486        access_token: impl AsRef<str>,
487        timeout: Option<Duration>,
488    ) -> crate::Result<Self> {
489        Ok(DnsUpdater::Netlify(NetlifyProvider::new(
490            access_token,
491            timeout,
492        )))
493    }
494
495    /// Create a new DNS updater using the INWX JSON-RPC API.
496    pub fn new_inwx(
497        username: impl Into<String>,
498        password: impl Into<String>,
499        sandbox: bool,
500        timeout: Option<Duration>,
501    ) -> crate::Result<Self> {
502        Ok(DnsUpdater::Inwx(InwxProvider::new(
503            username, password, sandbox, timeout,
504        )?))
505    }
506
507    /// Create a new DNS updater using the Alibaba Cloud DNS API.
508    pub fn new_alidns(
509        access_key: impl AsRef<str>,
510        secret_key: impl AsRef<str>,
511        region: Option<impl AsRef<str>>,
512        security_token: Option<impl AsRef<str>>,
513        line: Option<impl AsRef<str>>,
514        timeout: Option<Duration>,
515    ) -> crate::Result<Self> {
516        Ok(DnsUpdater::Alidns(AlidnsProvider::new(
517            access_key,
518            secret_key,
519            region,
520            security_token,
521            line,
522            timeout,
523        )?))
524    }
525
526    /// Create a new DNS updater using the Huawei Cloud DNS API.
527    pub fn new_huaweicloud(
528        access_key: impl AsRef<str>,
529        secret_key: impl AsRef<str>,
530        region: impl AsRef<str>,
531        timeout: Option<Duration>,
532    ) -> crate::Result<Self> {
533        Ok(DnsUpdater::HuaweiCloud(HuaweiCloudProvider::new(
534            access_key.as_ref(),
535            secret_key.as_ref(),
536            region.as_ref(),
537            timeout,
538        )?))
539    }
540
541    /// Create a new DNS updater using the ClouDNS API.
542    pub fn new_cloudns(
543        auth_id: Option<impl AsRef<str>>,
544        sub_auth_id: Option<impl AsRef<str>>,
545        auth_password: impl AsRef<str>,
546        timeout: Option<Duration>,
547    ) -> crate::Result<Self> {
548        Ok(DnsUpdater::ClouDns(ClouDnsProvider::new(
549            auth_id,
550            sub_auth_id,
551            auth_password,
552            timeout,
553        )?))
554    }
555
556    /// Create a new DNS updater using the Tencent Cloud DNSPod API.
557    pub fn new_tencentcloud(
558        secret_id: impl AsRef<str>,
559        secret_key: impl AsRef<str>,
560        region: Option<impl AsRef<str>>,
561        session_token: Option<impl AsRef<str>>,
562        timeout: Option<Duration>,
563    ) -> crate::Result<Self> {
564        Ok(DnsUpdater::TencentCloud(TencentCloudProvider::new(
565            secret_id,
566            secret_key,
567            region,
568            session_token,
569            timeout,
570        )?))
571    }
572
573    /// Create a new DNS updater using the Baidu Cloud DNS API.
574    pub fn new_baiducloud(
575        access_key: impl AsRef<str>,
576        secret_key: impl AsRef<str>,
577        timeout: Option<Duration>,
578    ) -> crate::Result<Self> {
579        Ok(DnsUpdater::BaiduCloud(BaiduCloudProvider::new(
580            access_key.as_ref(),
581            secret_key.as_ref(),
582            timeout,
583        )?))
584    }
585
586    /// Create a new DNS updater using the EasyDNS REST API.
587    pub fn new_easydns(
588        token: impl AsRef<str>,
589        key: impl AsRef<str>,
590        timeout: Option<Duration>,
591    ) -> crate::Result<Self> {
592        Ok(DnsUpdater::EasyDns(EasyDnsProvider::new(
593            token, key, timeout,
594        )?))
595    }
596
597    /// Create a new DNS updater using the Joker DMAPI.
598    pub fn new_joker(auth: JokerAuth, timeout: Option<Duration>) -> crate::Result<Self> {
599        Ok(DnsUpdater::Joker(JokerProvider::new(auth, timeout)?))
600    }
601
602    /// Create a new DNS updater using the Mythic Beasts DNSv2 API.
603    pub fn new_mythicbeasts(
604        username: impl AsRef<str>,
605        password: impl AsRef<str>,
606        timeout: Option<Duration>,
607    ) -> crate::Result<Self> {
608        Ok(DnsUpdater::MythicBeasts(MythicBeastsProvider::new(
609            username, password, timeout,
610        )?))
611    }
612
613    /// Create a new DNS updater using the Namecheap XML API.
614    pub fn new_namecheap(
615        api_user: impl AsRef<str>,
616        api_key: impl AsRef<str>,
617        client_ip: impl AsRef<str>,
618        username: Option<impl AsRef<str>>,
619        timeout: Option<Duration>,
620    ) -> crate::Result<Self> {
621        Ok(DnsUpdater::Namecheap(NamecheapProvider::new(
622            api_user, api_key, client_ip, username, timeout,
623        )?))
624    }
625
626    /// Create a new DNS updater using the TransIP v6 API.
627    #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
628    pub fn new_transip(
629        login: impl AsRef<str>,
630        private_key_pem: impl AsRef<str>,
631        global_key: bool,
632        timeout: Option<Duration>,
633    ) -> crate::Result<Self> {
634        Ok(DnsUpdater::Transip(TransipProvider::new(
635            login,
636            private_key_pem,
637            global_key,
638            timeout,
639        )?))
640    }
641
642    /// Create a new DNS updater using the Bluecat Address Manager v2 REST API.
643    pub fn new_bluecatv2(config: BluecatV2Config) -> crate::Result<Self> {
644        Ok(DnsUpdater::BluecatV2(BluecatV2Provider::new(config)?))
645    }
646
647    /// Create a new DNS updater using the GleSYS API.
648    pub fn new_glesys(
649        api_user: impl AsRef<str>,
650        api_key: impl AsRef<str>,
651        timeout: Option<Duration>,
652    ) -> crate::Result<Self> {
653        Ok(DnsUpdater::Glesys(GlesysProvider::new(
654            api_user, api_key, timeout,
655        )))
656    }
657
658    /// Create a new DNS updater using the Dreamhost API.
659    pub fn new_dreamhost(
660        api_key: impl AsRef<str>,
661        timeout: Option<Duration>,
662    ) -> crate::Result<Self> {
663        Ok(DnsUpdater::Dreamhost(DreamhostProvider::new(
664            api_key, timeout,
665        )))
666    }
667
668    /// Create a new DNS updater using the Volcano Engine API.
669    #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
670    pub fn new_volcengine(
671        config: crate::providers::volcengine::VolcengineConfig,
672    ) -> crate::Result<Self> {
673        Ok(DnsUpdater::Volcengine(
674            crate::providers::volcengine::VolcengineProvider::new(config)?,
675        ))
676    }
677
678    /// Create a new DNS updater using the Yandex Cloud DNS API.
679    #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
680    pub fn new_yandexcloud(
681        config: crate::providers::yandexcloud::YandexCloudConfig,
682    ) -> crate::Result<Self> {
683        Ok(DnsUpdater::YandexCloud(
684            crate::providers::yandexcloud::YandexCloudProvider::new(config)?,
685        ))
686    }
687
688    /// Create a new DNS updater using the Azure DNS REST API with OAuth2 client credentials.
689    pub fn new_azuredns(config: AzureDnsConfig) -> crate::Result<Self> {
690        Ok(DnsUpdater::AzureDns(AzureDnsProvider::new(config)?))
691    }
692
693    /// Create a new DNS updater using the IBM Cloud (SoftLayer classic) DNS API.
694    pub fn new_ibmcloud(
695        username: impl AsRef<str>,
696        api_key: impl AsRef<str>,
697        timeout: Option<Duration>,
698    ) -> crate::Result<Self> {
699        Ok(DnsUpdater::IbmCloud(IbmCloudProvider::new(
700            username, api_key, timeout,
701        )?))
702    }
703
704    /// Create a new DNS updater using the Hurricane Electric free DNS service.
705    pub fn new_hurricane(
706        credentials: HashMap<String, String>,
707        timeout: Option<Duration>,
708    ) -> crate::Result<Self> {
709        Ok(DnsUpdater::Hurricane(HurricaneProvider::new(
710            credentials,
711            timeout,
712        )?))
713    }
714
715    /// Create a new DNS updater using the Hostinger DNS API.
716    pub fn new_hostinger(
717        api_token: impl AsRef<str>,
718        timeout: Option<Duration>,
719    ) -> crate::Result<Self> {
720        Ok(DnsUpdater::Hostinger(HostingerProvider::new(
721            api_token, timeout,
722        )?))
723    }
724
725    /// Create a new DNS updater using the InterNetX AutoDNS API.
726    pub fn new_autodns(
727        username: impl AsRef<str>,
728        password: impl AsRef<str>,
729        context: Option<u32>,
730        timeout: Option<Duration>,
731    ) -> crate::Result<Self> {
732        Ok(DnsUpdater::Autodns(AutodnsProvider::new(
733            username, password, context, timeout,
734        )?))
735    }
736
737    /// Create a new DNS updater using the Plesk REST API (`X-API-Key` auth).
738    pub fn new_plesk(
739        base_url: impl AsRef<str>,
740        api_key: impl AsRef<str>,
741        timeout: Option<Duration>,
742    ) -> crate::Result<Self> {
743        Ok(DnsUpdater::Plesk(PleskProvider::new(
744            base_url, api_key, timeout,
745        )))
746    }
747
748    /// Create a new DNS updater using the cPanel UAPI (API token auth).
749    pub fn new_cpanel(
750        base_url: impl AsRef<str>,
751        username: impl AsRef<str>,
752        token: impl AsRef<str>,
753        timeout: Option<Duration>,
754    ) -> crate::Result<Self> {
755        Ok(DnsUpdater::Cpanel(CpanelProvider::new(
756            base_url, username, token, timeout,
757        )))
758    }
759
760    /// Create a new DNS updater using the AWS Lightsail DNS API.
761    pub fn new_lightsail(config: LightsailConfig) -> crate::Result<Self> {
762        Ok(DnsUpdater::Lightsail(LightsailProvider::new(config)?))
763    }
764
765    /// Create a new DNS updater using the Akamai EdgeDNS API.
766    pub fn new_edgedns(config: EdgeDnsConfig) -> crate::Result<Self> {
767        Ok(DnsUpdater::EdgeDns(EdgeDnsProvider::new(config)?))
768    }
769
770    /// Create a new DNS updater using the UltraDNS REST API.
771    pub fn new_ultradns(
772        username: impl Into<String>,
773        password: impl Into<String>,
774        endpoint: Option<String>,
775        timeout: Option<Duration>,
776    ) -> crate::Result<Self> {
777        Ok(DnsUpdater::UltraDns(UltraDnsProvider::new(
778            username, password, endpoint, timeout,
779        )?))
780    }
781
782    /// Create a new DNS updater using the Infoblox NIOS WAPI.
783    pub fn new_infoblox(config: InfobloxConfig) -> crate::Result<Self> {
784        Ok(DnsUpdater::Infoblox(InfobloxProvider::new(config)?))
785    }
786
787    /// Create a new DNS updater using the Pebble Challenge Test Server.
788    #[cfg(feature = "test_provider")]
789    pub fn new_pebble(base_url: impl AsRef<str>, timeout: Option<Duration>) -> Self {
790        DnsUpdater::Pebble(PebbleProvider::new(base_url, timeout))
791    }
792
793    /// Create a new DNS updater backed by an in-memory record store.
794    #[cfg(feature = "test_provider")]
795    pub fn new_in_memory(records: Arc<Mutex<Vec<NamedDnsRecord>>>) -> Self {
796        DnsUpdater::InMemory(InMemoryProvider::new(records))
797    }
798
799    /// Atomically replace the RRSet at (name, type). An empty `records` Vec deletes the RRSet.
800    pub async fn set_rrset(
801        &self,
802        name: impl IntoFqdn<'_>,
803        record_type: DnsRecordType,
804        ttl: u32,
805        records: Vec<DnsRecord>,
806        origin: impl IntoFqdn<'_>,
807    ) -> crate::Result<()> {
808        match self {
809            DnsUpdater::Rfc2136(provider) => {
810                provider
811                    .set_rrset(name, record_type, ttl, records, origin)
812                    .await
813            }
814            DnsUpdater::Cloudflare(provider) => {
815                provider
816                    .set_rrset(name, record_type, ttl, records, origin)
817                    .await
818            }
819            DnsUpdater::DigitalOcean(provider) => {
820                provider
821                    .set_rrset(name, record_type, ttl, records, origin)
822                    .await
823            }
824            DnsUpdater::Desec(provider) => {
825                provider
826                    .set_rrset(name, record_type, ttl, records, origin)
827                    .await
828            }
829            DnsUpdater::Constellix(provider) => {
830                provider
831                    .set_rrset(name, record_type, ttl, records, origin)
832                    .await
833            }
834            DnsUpdater::DnsMadeEasy(provider) => {
835                provider
836                    .set_rrset(name, record_type, ttl, records, origin)
837                    .await
838            }
839            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
840            DnsUpdater::Ovh(provider) => {
841                provider
842                    .set_rrset(name, record_type, ttl, records, origin)
843                    .await
844            }
845            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
846            DnsUpdater::OracleCloud(provider) => {
847                provider
848                    .set_rrset(name, record_type, ttl, records, origin)
849                    .await
850            }
851            DnsUpdater::Bunny(provider) => {
852                provider
853                    .set_rrset(name, record_type, ttl, records, origin)
854                    .await
855            }
856            DnsUpdater::Linode(provider) => {
857                provider
858                    .set_rrset(name, record_type, ttl, records, origin)
859                    .await
860            }
861            DnsUpdater::Porkbun(provider) => {
862                provider
863                    .set_rrset(name, record_type, ttl, records, origin)
864                    .await
865            }
866            DnsUpdater::Exoscale(provider) => {
867                provider
868                    .set_rrset(name, record_type, ttl, records, origin)
869                    .await
870            }
871            DnsUpdater::Nifcloud(provider) => {
872                provider
873                    .set_rrset(name, record_type, ttl, records, origin)
874                    .await
875            }
876            DnsUpdater::WebSupport(provider) => {
877                provider
878                    .set_rrset(name, record_type, ttl, records, origin)
879                    .await
880            }
881            DnsUpdater::Spaceship(provider) => {
882                provider
883                    .set_rrset(name, record_type, ttl, records, origin)
884                    .await
885            }
886            DnsUpdater::DNSimple(provider) => {
887                provider
888                    .set_rrset(name, record_type, ttl, records, origin)
889                    .await
890            }
891            DnsUpdater::GandiV5(provider) => {
892                provider
893                    .set_rrset(name, record_type, ttl, records, origin)
894                    .await
895            }
896            DnsUpdater::Godaddy(provider) => {
897                provider
898                    .set_rrset(name, record_type, ttl, records, origin)
899                    .await
900            }
901            DnsUpdater::Hetzner(provider) => {
902                provider
903                    .set_rrset(name, record_type, ttl, records, origin)
904                    .await
905            }
906            DnsUpdater::NameDotCom(provider) => {
907                provider
908                    .set_rrset(name, record_type, ttl, records, origin)
909                    .await
910            }
911            DnsUpdater::NameSilo(provider) => {
912                provider
913                    .set_rrset(name, record_type, ttl, records, origin)
914                    .await
915            }
916            DnsUpdater::DuckDns(provider) => {
917                provider
918                    .set_rrset(name, record_type, ttl, records, origin)
919                    .await
920            }
921            DnsUpdater::FreeMyIp(provider) => {
922                provider
923                    .set_rrset(name, record_type, ttl, records, origin)
924                    .await
925            }
926            DnsUpdater::Ipv64(provider) => {
927                provider
928                    .set_rrset(name, record_type, ttl, records, origin)
929                    .await
930            }
931            DnsUpdater::Ddnss(provider) => {
932                provider
933                    .set_rrset(name, record_type, ttl, records, origin)
934                    .await
935            }
936            DnsUpdater::Dynu(provider) => {
937                provider
938                    .set_rrset(name, record_type, ttl, records, origin)
939                    .await
940            }
941            DnsUpdater::GoogleCloudDns(provider) => {
942                provider
943                    .set_rrset(name, record_type, ttl, records, origin)
944                    .await
945            }
946            DnsUpdater::Route53(provider) => {
947                provider
948                    .set_rrset(name, record_type, ttl, records, origin)
949                    .await
950            }
951            DnsUpdater::Vultr(provider) => {
952                provider
953                    .set_rrset(name, record_type, ttl, records, origin)
954                    .await
955            }
956            DnsUpdater::Scaleway(provider) => {
957                provider
958                    .set_rrset(name, record_type, ttl, records, origin)
959                    .await
960            }
961            DnsUpdater::Gcore(provider) => {
962                provider
963                    .set_rrset(name, record_type, ttl, records, origin)
964                    .await
965            }
966            DnsUpdater::Vercel(provider) => {
967                provider
968                    .set_rrset(name, record_type, ttl, records, origin)
969                    .await
970            }
971            DnsUpdater::Ionos(provider) => {
972                provider
973                    .set_rrset(name, record_type, ttl, records, origin)
974                    .await
975            }
976            DnsUpdater::HostingDe(provider) => {
977                provider
978                    .set_rrset(name, record_type, ttl, records, origin)
979                    .await
980            }
981            DnsUpdater::Domeneshop(provider) => {
982                provider
983                    .set_rrset(name, record_type, ttl, records, origin)
984                    .await
985            }
986            DnsUpdater::Safedns(provider) => {
987                provider
988                    .set_rrset(name, record_type, ttl, records, origin)
989                    .await
990            }
991            DnsUpdater::ArvanCloud(provider) => {
992                provider
993                    .set_rrset(name, record_type, ttl, records, origin)
994                    .await
995            }
996            DnsUpdater::Infomaniak(provider) => {
997                provider
998                    .set_rrset(name, record_type, ttl, records, origin)
999                    .await
1000            }
1001            DnsUpdater::Ns1(provider) => {
1002                provider
1003                    .set_rrset(name, record_type, ttl, records, origin)
1004                    .await
1005            }
1006            DnsUpdater::LuaDns(provider) => {
1007                provider
1008                    .set_rrset(name, record_type, ttl, records, origin)
1009                    .await
1010            }
1011            DnsUpdater::Netcup(provider) => {
1012                provider
1013                    .set_rrset(name, record_type, ttl, records, origin)
1014                    .await
1015            }
1016            DnsUpdater::Netlify(provider) => {
1017                provider
1018                    .set_rrset(name, record_type, ttl, records, origin)
1019                    .await
1020            }
1021            DnsUpdater::Inwx(provider) => {
1022                provider
1023                    .set_rrset(name, record_type, ttl, records, origin)
1024                    .await
1025            }
1026            DnsUpdater::Alidns(provider) => {
1027                provider
1028                    .set_rrset(name, record_type, ttl, records, origin)
1029                    .await
1030            }
1031            DnsUpdater::HuaweiCloud(provider) => {
1032                provider
1033                    .set_rrset(name, record_type, ttl, records, origin)
1034                    .await
1035            }
1036            DnsUpdater::ClouDns(provider) => {
1037                provider
1038                    .set_rrset(name, record_type, ttl, records, origin)
1039                    .await
1040            }
1041            DnsUpdater::TencentCloud(provider) => {
1042                provider
1043                    .set_rrset(name, record_type, ttl, records, origin)
1044                    .await
1045            }
1046            DnsUpdater::BaiduCloud(provider) => {
1047                provider
1048                    .set_rrset(name, record_type, ttl, records, origin)
1049                    .await
1050            }
1051            DnsUpdater::EasyDns(provider) => {
1052                provider
1053                    .set_rrset(name, record_type, ttl, records, origin)
1054                    .await
1055            }
1056            DnsUpdater::Joker(provider) => {
1057                provider
1058                    .set_rrset(name, record_type, ttl, records, origin)
1059                    .await
1060            }
1061            DnsUpdater::MythicBeasts(provider) => {
1062                provider
1063                    .set_rrset(name, record_type, ttl, records, origin)
1064                    .await
1065            }
1066            DnsUpdater::Namecheap(provider) => {
1067                provider
1068                    .set_rrset(name, record_type, ttl, records, origin)
1069                    .await
1070            }
1071            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1072            DnsUpdater::Transip(provider) => {
1073                provider
1074                    .set_rrset(name, record_type, ttl, records, origin)
1075                    .await
1076            }
1077            DnsUpdater::BluecatV2(provider) => {
1078                provider
1079                    .set_rrset(name, record_type, ttl, records, origin)
1080                    .await
1081            }
1082            DnsUpdater::Glesys(provider) => {
1083                provider
1084                    .set_rrset(name, record_type, ttl, records, origin)
1085                    .await
1086            }
1087            DnsUpdater::Dreamhost(provider) => {
1088                provider
1089                    .set_rrset(name, record_type, ttl, records, origin)
1090                    .await
1091            }
1092            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1093            DnsUpdater::Volcengine(provider) => {
1094                provider
1095                    .set_rrset(name, record_type, ttl, records, origin)
1096                    .await
1097            }
1098            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1099            DnsUpdater::YandexCloud(provider) => {
1100                provider
1101                    .set_rrset(name, record_type, ttl, records, origin)
1102                    .await
1103            }
1104            DnsUpdater::AzureDns(provider) => {
1105                provider
1106                    .set_rrset(name, record_type, ttl, records, origin)
1107                    .await
1108            }
1109            DnsUpdater::IbmCloud(provider) => {
1110                provider
1111                    .set_rrset(name, record_type, ttl, records, origin)
1112                    .await
1113            }
1114            DnsUpdater::Hurricane(provider) => {
1115                provider
1116                    .set_rrset(name, record_type, ttl, records, origin)
1117                    .await
1118            }
1119            DnsUpdater::Hostinger(provider) => {
1120                provider
1121                    .set_rrset(name, record_type, ttl, records, origin)
1122                    .await
1123            }
1124            DnsUpdater::Autodns(provider) => {
1125                provider
1126                    .set_rrset(name, record_type, ttl, records, origin)
1127                    .await
1128            }
1129            DnsUpdater::Plesk(provider) => {
1130                provider
1131                    .set_rrset(name, record_type, ttl, records, origin)
1132                    .await
1133            }
1134            DnsUpdater::Cpanel(provider) => {
1135                provider
1136                    .set_rrset(name, record_type, ttl, records, origin)
1137                    .await
1138            }
1139            DnsUpdater::Lightsail(provider) => {
1140                provider
1141                    .set_rrset(name, record_type, ttl, records, origin)
1142                    .await
1143            }
1144            DnsUpdater::EdgeDns(provider) => {
1145                provider
1146                    .set_rrset(name, record_type, ttl, records, origin)
1147                    .await
1148            }
1149            DnsUpdater::UltraDns(provider) => {
1150                provider
1151                    .set_rrset(name, record_type, ttl, records, origin)
1152                    .await
1153            }
1154            DnsUpdater::Infoblox(provider) => {
1155                provider
1156                    .set_rrset(name, record_type, ttl, records, origin)
1157                    .await
1158            }
1159            #[cfg(feature = "test_provider")]
1160            DnsUpdater::Pebble(provider) => {
1161                provider
1162                    .set_rrset(name, record_type, ttl, records, origin)
1163                    .await
1164            }
1165            #[cfg(feature = "test_provider")]
1166            DnsUpdater::InMemory(provider) => {
1167                provider
1168                    .set_rrset(name, record_type, ttl, records, origin)
1169                    .await
1170            }
1171        }
1172    }
1173
1174    /// Add records to the RRSet at (name, type). Idempotent: values already present are skipped.
1175    pub async fn add_to_rrset(
1176        &self,
1177        name: impl IntoFqdn<'_>,
1178        record_type: DnsRecordType,
1179        ttl: u32,
1180        records: Vec<DnsRecord>,
1181        origin: impl IntoFqdn<'_>,
1182    ) -> crate::Result<()> {
1183        match self {
1184            DnsUpdater::Rfc2136(provider) => {
1185                provider
1186                    .add_to_rrset(name, record_type, ttl, records, origin)
1187                    .await
1188            }
1189            DnsUpdater::Cloudflare(provider) => {
1190                provider
1191                    .add_to_rrset(name, record_type, ttl, records, origin)
1192                    .await
1193            }
1194            DnsUpdater::DigitalOcean(provider) => {
1195                provider
1196                    .add_to_rrset(name, record_type, ttl, records, origin)
1197                    .await
1198            }
1199            DnsUpdater::Desec(provider) => {
1200                provider
1201                    .add_to_rrset(name, record_type, ttl, records, origin)
1202                    .await
1203            }
1204            DnsUpdater::Constellix(provider) => {
1205                provider
1206                    .add_to_rrset(name, record_type, ttl, records, origin)
1207                    .await
1208            }
1209            DnsUpdater::DnsMadeEasy(provider) => {
1210                provider
1211                    .add_to_rrset(name, record_type, ttl, records, origin)
1212                    .await
1213            }
1214            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1215            DnsUpdater::Ovh(provider) => {
1216                provider
1217                    .add_to_rrset(name, record_type, ttl, records, origin)
1218                    .await
1219            }
1220            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1221            DnsUpdater::OracleCloud(provider) => {
1222                provider
1223                    .add_to_rrset(name, record_type, ttl, records, origin)
1224                    .await
1225            }
1226            DnsUpdater::Bunny(provider) => {
1227                provider
1228                    .add_to_rrset(name, record_type, ttl, records, origin)
1229                    .await
1230            }
1231            DnsUpdater::Linode(provider) => {
1232                provider
1233                    .add_to_rrset(name, record_type, ttl, records, origin)
1234                    .await
1235            }
1236            DnsUpdater::Porkbun(provider) => {
1237                provider
1238                    .add_to_rrset(name, record_type, ttl, records, origin)
1239                    .await
1240            }
1241            DnsUpdater::Exoscale(provider) => {
1242                provider
1243                    .add_to_rrset(name, record_type, ttl, records, origin)
1244                    .await
1245            }
1246            DnsUpdater::Nifcloud(provider) => {
1247                provider
1248                    .add_to_rrset(name, record_type, ttl, records, origin)
1249                    .await
1250            }
1251            DnsUpdater::WebSupport(provider) => {
1252                provider
1253                    .add_to_rrset(name, record_type, ttl, records, origin)
1254                    .await
1255            }
1256            DnsUpdater::Spaceship(provider) => {
1257                provider
1258                    .add_to_rrset(name, record_type, ttl, records, origin)
1259                    .await
1260            }
1261            DnsUpdater::DNSimple(provider) => {
1262                provider
1263                    .add_to_rrset(name, record_type, ttl, records, origin)
1264                    .await
1265            }
1266            DnsUpdater::GandiV5(provider) => {
1267                provider
1268                    .add_to_rrset(name, record_type, ttl, records, origin)
1269                    .await
1270            }
1271            DnsUpdater::Godaddy(provider) => {
1272                provider
1273                    .add_to_rrset(name, record_type, ttl, records, origin)
1274                    .await
1275            }
1276            DnsUpdater::Hetzner(provider) => {
1277                provider
1278                    .add_to_rrset(name, record_type, ttl, records, origin)
1279                    .await
1280            }
1281            DnsUpdater::NameDotCom(provider) => {
1282                provider
1283                    .add_to_rrset(name, record_type, ttl, records, origin)
1284                    .await
1285            }
1286            DnsUpdater::NameSilo(provider) => {
1287                provider
1288                    .add_to_rrset(name, record_type, ttl, records, origin)
1289                    .await
1290            }
1291            DnsUpdater::DuckDns(provider) => {
1292                provider
1293                    .add_to_rrset(name, record_type, ttl, records, origin)
1294                    .await
1295            }
1296            DnsUpdater::FreeMyIp(provider) => {
1297                provider
1298                    .add_to_rrset(name, record_type, ttl, records, origin)
1299                    .await
1300            }
1301            DnsUpdater::Ipv64(provider) => {
1302                provider
1303                    .add_to_rrset(name, record_type, ttl, records, origin)
1304                    .await
1305            }
1306            DnsUpdater::Ddnss(provider) => {
1307                provider
1308                    .add_to_rrset(name, record_type, ttl, records, origin)
1309                    .await
1310            }
1311            DnsUpdater::Dynu(provider) => {
1312                provider
1313                    .add_to_rrset(name, record_type, ttl, records, origin)
1314                    .await
1315            }
1316            DnsUpdater::GoogleCloudDns(provider) => {
1317                provider
1318                    .add_to_rrset(name, record_type, ttl, records, origin)
1319                    .await
1320            }
1321            DnsUpdater::Route53(provider) => {
1322                provider
1323                    .add_to_rrset(name, record_type, ttl, records, origin)
1324                    .await
1325            }
1326            DnsUpdater::Vultr(provider) => {
1327                provider
1328                    .add_to_rrset(name, record_type, ttl, records, origin)
1329                    .await
1330            }
1331            DnsUpdater::Scaleway(provider) => {
1332                provider
1333                    .add_to_rrset(name, record_type, ttl, records, origin)
1334                    .await
1335            }
1336            DnsUpdater::Gcore(provider) => {
1337                provider
1338                    .add_to_rrset(name, record_type, ttl, records, origin)
1339                    .await
1340            }
1341            DnsUpdater::Vercel(provider) => {
1342                provider
1343                    .add_to_rrset(name, record_type, ttl, records, origin)
1344                    .await
1345            }
1346            DnsUpdater::Ionos(provider) => {
1347                provider
1348                    .add_to_rrset(name, record_type, ttl, records, origin)
1349                    .await
1350            }
1351            DnsUpdater::HostingDe(provider) => {
1352                provider
1353                    .add_to_rrset(name, record_type, ttl, records, origin)
1354                    .await
1355            }
1356            DnsUpdater::Domeneshop(provider) => {
1357                provider
1358                    .add_to_rrset(name, record_type, ttl, records, origin)
1359                    .await
1360            }
1361            DnsUpdater::Safedns(provider) => {
1362                provider
1363                    .add_to_rrset(name, record_type, ttl, records, origin)
1364                    .await
1365            }
1366            DnsUpdater::ArvanCloud(provider) => {
1367                provider
1368                    .add_to_rrset(name, record_type, ttl, records, origin)
1369                    .await
1370            }
1371            DnsUpdater::Infomaniak(provider) => {
1372                provider
1373                    .add_to_rrset(name, record_type, ttl, records, origin)
1374                    .await
1375            }
1376            DnsUpdater::Ns1(provider) => {
1377                provider
1378                    .add_to_rrset(name, record_type, ttl, records, origin)
1379                    .await
1380            }
1381            DnsUpdater::LuaDns(provider) => {
1382                provider
1383                    .add_to_rrset(name, record_type, ttl, records, origin)
1384                    .await
1385            }
1386            DnsUpdater::Netcup(provider) => {
1387                provider
1388                    .add_to_rrset(name, record_type, ttl, records, origin)
1389                    .await
1390            }
1391            DnsUpdater::Netlify(provider) => {
1392                provider
1393                    .add_to_rrset(name, record_type, ttl, records, origin)
1394                    .await
1395            }
1396            DnsUpdater::Inwx(provider) => {
1397                provider
1398                    .add_to_rrset(name, record_type, ttl, records, origin)
1399                    .await
1400            }
1401            DnsUpdater::Alidns(provider) => {
1402                provider
1403                    .add_to_rrset(name, record_type, ttl, records, origin)
1404                    .await
1405            }
1406            DnsUpdater::HuaweiCloud(provider) => {
1407                provider
1408                    .add_to_rrset(name, record_type, ttl, records, origin)
1409                    .await
1410            }
1411            DnsUpdater::ClouDns(provider) => {
1412                provider
1413                    .add_to_rrset(name, record_type, ttl, records, origin)
1414                    .await
1415            }
1416            DnsUpdater::TencentCloud(provider) => {
1417                provider
1418                    .add_to_rrset(name, record_type, ttl, records, origin)
1419                    .await
1420            }
1421            DnsUpdater::BaiduCloud(provider) => {
1422                provider
1423                    .add_to_rrset(name, record_type, ttl, records, origin)
1424                    .await
1425            }
1426            DnsUpdater::EasyDns(provider) => {
1427                provider
1428                    .add_to_rrset(name, record_type, ttl, records, origin)
1429                    .await
1430            }
1431            DnsUpdater::Joker(provider) => {
1432                provider
1433                    .add_to_rrset(name, record_type, ttl, records, origin)
1434                    .await
1435            }
1436            DnsUpdater::MythicBeasts(provider) => {
1437                provider
1438                    .add_to_rrset(name, record_type, ttl, records, origin)
1439                    .await
1440            }
1441            DnsUpdater::Namecheap(provider) => {
1442                provider
1443                    .add_to_rrset(name, record_type, ttl, records, origin)
1444                    .await
1445            }
1446            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1447            DnsUpdater::Transip(provider) => {
1448                provider
1449                    .add_to_rrset(name, record_type, ttl, records, origin)
1450                    .await
1451            }
1452            DnsUpdater::BluecatV2(provider) => {
1453                provider
1454                    .add_to_rrset(name, record_type, ttl, records, origin)
1455                    .await
1456            }
1457            DnsUpdater::Glesys(provider) => {
1458                provider
1459                    .add_to_rrset(name, record_type, ttl, records, origin)
1460                    .await
1461            }
1462            DnsUpdater::Dreamhost(provider) => {
1463                provider
1464                    .add_to_rrset(name, record_type, ttl, records, origin)
1465                    .await
1466            }
1467            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1468            DnsUpdater::Volcengine(provider) => {
1469                provider
1470                    .add_to_rrset(name, record_type, ttl, records, origin)
1471                    .await
1472            }
1473            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1474            DnsUpdater::YandexCloud(provider) => {
1475                provider
1476                    .add_to_rrset(name, record_type, ttl, records, origin)
1477                    .await
1478            }
1479            DnsUpdater::AzureDns(provider) => {
1480                provider
1481                    .add_to_rrset(name, record_type, ttl, records, origin)
1482                    .await
1483            }
1484            DnsUpdater::IbmCloud(provider) => {
1485                provider
1486                    .add_to_rrset(name, record_type, ttl, records, origin)
1487                    .await
1488            }
1489            DnsUpdater::Hurricane(provider) => {
1490                provider
1491                    .add_to_rrset(name, record_type, ttl, records, origin)
1492                    .await
1493            }
1494            DnsUpdater::Hostinger(provider) => {
1495                provider
1496                    .add_to_rrset(name, record_type, ttl, records, origin)
1497                    .await
1498            }
1499            DnsUpdater::Autodns(provider) => {
1500                provider
1501                    .add_to_rrset(name, record_type, ttl, records, origin)
1502                    .await
1503            }
1504            DnsUpdater::Plesk(provider) => {
1505                provider
1506                    .add_to_rrset(name, record_type, ttl, records, origin)
1507                    .await
1508            }
1509            DnsUpdater::Cpanel(provider) => {
1510                provider
1511                    .add_to_rrset(name, record_type, ttl, records, origin)
1512                    .await
1513            }
1514            DnsUpdater::Lightsail(provider) => {
1515                provider
1516                    .add_to_rrset(name, record_type, ttl, records, origin)
1517                    .await
1518            }
1519            DnsUpdater::EdgeDns(provider) => {
1520                provider
1521                    .add_to_rrset(name, record_type, ttl, records, origin)
1522                    .await
1523            }
1524            DnsUpdater::UltraDns(provider) => {
1525                provider
1526                    .add_to_rrset(name, record_type, ttl, records, origin)
1527                    .await
1528            }
1529            DnsUpdater::Infoblox(provider) => {
1530                provider
1531                    .add_to_rrset(name, record_type, ttl, records, origin)
1532                    .await
1533            }
1534            #[cfg(feature = "test_provider")]
1535            DnsUpdater::Pebble(provider) => {
1536                provider
1537                    .add_to_rrset(name, record_type, ttl, records, origin)
1538                    .await
1539            }
1540            #[cfg(feature = "test_provider")]
1541            DnsUpdater::InMemory(provider) => {
1542                provider
1543                    .add_to_rrset(name, record_type, ttl, records, origin)
1544                    .await
1545            }
1546        }
1547    }
1548
1549    /// Remove the listed records from the RRSet at (name, type). Idempotent: values not present are skipped.
1550    pub async fn remove_from_rrset(
1551        &self,
1552        name: impl IntoFqdn<'_>,
1553        record_type: DnsRecordType,
1554        records: Vec<DnsRecord>,
1555        origin: impl IntoFqdn<'_>,
1556    ) -> crate::Result<()> {
1557        match self {
1558            DnsUpdater::Rfc2136(provider) => {
1559                provider
1560                    .remove_from_rrset(name, record_type, records, origin)
1561                    .await
1562            }
1563            DnsUpdater::Cloudflare(provider) => {
1564                provider
1565                    .remove_from_rrset(name, record_type, records, origin)
1566                    .await
1567            }
1568            DnsUpdater::DigitalOcean(provider) => {
1569                provider
1570                    .remove_from_rrset(name, record_type, records, origin)
1571                    .await
1572            }
1573            DnsUpdater::Desec(provider) => {
1574                provider
1575                    .remove_from_rrset(name, record_type, records, origin)
1576                    .await
1577            }
1578            DnsUpdater::Constellix(provider) => {
1579                provider
1580                    .remove_from_rrset(name, record_type, records, origin)
1581                    .await
1582            }
1583            DnsUpdater::DnsMadeEasy(provider) => {
1584                provider
1585                    .remove_from_rrset(name, record_type, records, origin)
1586                    .await
1587            }
1588            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1589            DnsUpdater::Ovh(provider) => {
1590                provider
1591                    .remove_from_rrset(name, record_type, records, origin)
1592                    .await
1593            }
1594            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1595            DnsUpdater::OracleCloud(provider) => {
1596                provider
1597                    .remove_from_rrset(name, record_type, records, origin)
1598                    .await
1599            }
1600            DnsUpdater::Bunny(provider) => {
1601                provider
1602                    .remove_from_rrset(name, record_type, records, origin)
1603                    .await
1604            }
1605            DnsUpdater::Linode(provider) => {
1606                provider
1607                    .remove_from_rrset(name, record_type, records, origin)
1608                    .await
1609            }
1610            DnsUpdater::Porkbun(provider) => {
1611                provider
1612                    .remove_from_rrset(name, record_type, records, origin)
1613                    .await
1614            }
1615            DnsUpdater::Exoscale(provider) => {
1616                provider
1617                    .remove_from_rrset(name, record_type, records, origin)
1618                    .await
1619            }
1620            DnsUpdater::Nifcloud(provider) => {
1621                provider
1622                    .remove_from_rrset(name, record_type, records, origin)
1623                    .await
1624            }
1625            DnsUpdater::WebSupport(provider) => {
1626                provider
1627                    .remove_from_rrset(name, record_type, records, origin)
1628                    .await
1629            }
1630            DnsUpdater::Spaceship(provider) => {
1631                provider
1632                    .remove_from_rrset(name, record_type, records, origin)
1633                    .await
1634            }
1635            DnsUpdater::DNSimple(provider) => {
1636                provider
1637                    .remove_from_rrset(name, record_type, records, origin)
1638                    .await
1639            }
1640            DnsUpdater::GandiV5(provider) => {
1641                provider
1642                    .remove_from_rrset(name, record_type, records, origin)
1643                    .await
1644            }
1645            DnsUpdater::Godaddy(provider) => {
1646                provider
1647                    .remove_from_rrset(name, record_type, records, origin)
1648                    .await
1649            }
1650            DnsUpdater::Hetzner(provider) => {
1651                provider
1652                    .remove_from_rrset(name, record_type, records, origin)
1653                    .await
1654            }
1655            DnsUpdater::NameDotCom(provider) => {
1656                provider
1657                    .remove_from_rrset(name, record_type, records, origin)
1658                    .await
1659            }
1660            DnsUpdater::NameSilo(provider) => {
1661                provider
1662                    .remove_from_rrset(name, record_type, records, origin)
1663                    .await
1664            }
1665            DnsUpdater::DuckDns(provider) => {
1666                provider
1667                    .remove_from_rrset(name, record_type, records, origin)
1668                    .await
1669            }
1670            DnsUpdater::FreeMyIp(provider) => {
1671                provider
1672                    .remove_from_rrset(name, record_type, records, origin)
1673                    .await
1674            }
1675            DnsUpdater::Ipv64(provider) => {
1676                provider
1677                    .remove_from_rrset(name, record_type, records, origin)
1678                    .await
1679            }
1680            DnsUpdater::Ddnss(provider) => {
1681                provider
1682                    .remove_from_rrset(name, record_type, records, origin)
1683                    .await
1684            }
1685            DnsUpdater::Dynu(provider) => {
1686                provider
1687                    .remove_from_rrset(name, record_type, records, origin)
1688                    .await
1689            }
1690            DnsUpdater::GoogleCloudDns(provider) => {
1691                provider
1692                    .remove_from_rrset(name, record_type, records, origin)
1693                    .await
1694            }
1695            DnsUpdater::Route53(provider) => {
1696                provider
1697                    .remove_from_rrset(name, record_type, records, origin)
1698                    .await
1699            }
1700            DnsUpdater::Vultr(provider) => {
1701                provider
1702                    .remove_from_rrset(name, record_type, records, origin)
1703                    .await
1704            }
1705            DnsUpdater::Scaleway(provider) => {
1706                provider
1707                    .remove_from_rrset(name, record_type, records, origin)
1708                    .await
1709            }
1710            DnsUpdater::Gcore(provider) => {
1711                provider
1712                    .remove_from_rrset(name, record_type, records, origin)
1713                    .await
1714            }
1715            DnsUpdater::Vercel(provider) => {
1716                provider
1717                    .remove_from_rrset(name, record_type, records, origin)
1718                    .await
1719            }
1720            DnsUpdater::Ionos(provider) => {
1721                provider
1722                    .remove_from_rrset(name, record_type, records, origin)
1723                    .await
1724            }
1725            DnsUpdater::HostingDe(provider) => {
1726                provider
1727                    .remove_from_rrset(name, record_type, records, origin)
1728                    .await
1729            }
1730            DnsUpdater::Domeneshop(provider) => {
1731                provider
1732                    .remove_from_rrset(name, record_type, records, origin)
1733                    .await
1734            }
1735            DnsUpdater::Safedns(provider) => {
1736                provider
1737                    .remove_from_rrset(name, record_type, records, origin)
1738                    .await
1739            }
1740            DnsUpdater::ArvanCloud(provider) => {
1741                provider
1742                    .remove_from_rrset(name, record_type, records, origin)
1743                    .await
1744            }
1745            DnsUpdater::Infomaniak(provider) => {
1746                provider
1747                    .remove_from_rrset(name, record_type, records, origin)
1748                    .await
1749            }
1750            DnsUpdater::Ns1(provider) => {
1751                provider
1752                    .remove_from_rrset(name, record_type, records, origin)
1753                    .await
1754            }
1755            DnsUpdater::LuaDns(provider) => {
1756                provider
1757                    .remove_from_rrset(name, record_type, records, origin)
1758                    .await
1759            }
1760            DnsUpdater::Netcup(provider) => {
1761                provider
1762                    .remove_from_rrset(name, record_type, records, origin)
1763                    .await
1764            }
1765            DnsUpdater::Netlify(provider) => {
1766                provider
1767                    .remove_from_rrset(name, record_type, records, origin)
1768                    .await
1769            }
1770            DnsUpdater::Inwx(provider) => {
1771                provider
1772                    .remove_from_rrset(name, record_type, records, origin)
1773                    .await
1774            }
1775            DnsUpdater::Alidns(provider) => {
1776                provider
1777                    .remove_from_rrset(name, record_type, records, origin)
1778                    .await
1779            }
1780            DnsUpdater::HuaweiCloud(provider) => {
1781                provider
1782                    .remove_from_rrset(name, record_type, records, origin)
1783                    .await
1784            }
1785            DnsUpdater::ClouDns(provider) => {
1786                provider
1787                    .remove_from_rrset(name, record_type, records, origin)
1788                    .await
1789            }
1790            DnsUpdater::TencentCloud(provider) => {
1791                provider
1792                    .remove_from_rrset(name, record_type, records, origin)
1793                    .await
1794            }
1795            DnsUpdater::BaiduCloud(provider) => {
1796                provider
1797                    .remove_from_rrset(name, record_type, records, origin)
1798                    .await
1799            }
1800            DnsUpdater::EasyDns(provider) => {
1801                provider
1802                    .remove_from_rrset(name, record_type, records, origin)
1803                    .await
1804            }
1805            DnsUpdater::Joker(provider) => {
1806                provider
1807                    .remove_from_rrset(name, record_type, records, origin)
1808                    .await
1809            }
1810            DnsUpdater::MythicBeasts(provider) => {
1811                provider
1812                    .remove_from_rrset(name, record_type, records, origin)
1813                    .await
1814            }
1815            DnsUpdater::Namecheap(provider) => {
1816                provider
1817                    .remove_from_rrset(name, record_type, records, origin)
1818                    .await
1819            }
1820            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1821            DnsUpdater::Transip(provider) => {
1822                provider
1823                    .remove_from_rrset(name, record_type, records, origin)
1824                    .await
1825            }
1826            DnsUpdater::BluecatV2(provider) => {
1827                provider
1828                    .remove_from_rrset(name, record_type, records, origin)
1829                    .await
1830            }
1831            DnsUpdater::Glesys(provider) => {
1832                provider
1833                    .remove_from_rrset(name, record_type, records, origin)
1834                    .await
1835            }
1836            DnsUpdater::Dreamhost(provider) => {
1837                provider
1838                    .remove_from_rrset(name, record_type, records, origin)
1839                    .await
1840            }
1841            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1842            DnsUpdater::Volcengine(provider) => {
1843                provider
1844                    .remove_from_rrset(name, record_type, records, origin)
1845                    .await
1846            }
1847            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1848            DnsUpdater::YandexCloud(provider) => {
1849                provider
1850                    .remove_from_rrset(name, record_type, records, origin)
1851                    .await
1852            }
1853            DnsUpdater::AzureDns(provider) => {
1854                provider
1855                    .remove_from_rrset(name, record_type, records, origin)
1856                    .await
1857            }
1858            DnsUpdater::IbmCloud(provider) => {
1859                provider
1860                    .remove_from_rrset(name, record_type, records, origin)
1861                    .await
1862            }
1863            DnsUpdater::Hurricane(provider) => {
1864                provider
1865                    .remove_from_rrset(name, record_type, records, origin)
1866                    .await
1867            }
1868            DnsUpdater::Hostinger(provider) => {
1869                provider
1870                    .remove_from_rrset(name, record_type, records, origin)
1871                    .await
1872            }
1873            DnsUpdater::Autodns(provider) => {
1874                provider
1875                    .remove_from_rrset(name, record_type, records, origin)
1876                    .await
1877            }
1878            DnsUpdater::Plesk(provider) => {
1879                provider
1880                    .remove_from_rrset(name, record_type, records, origin)
1881                    .await
1882            }
1883            DnsUpdater::Cpanel(provider) => {
1884                provider
1885                    .remove_from_rrset(name, record_type, records, origin)
1886                    .await
1887            }
1888            DnsUpdater::Lightsail(provider) => {
1889                provider
1890                    .remove_from_rrset(name, record_type, records, origin)
1891                    .await
1892            }
1893            DnsUpdater::EdgeDns(provider) => {
1894                provider
1895                    .remove_from_rrset(name, record_type, records, origin)
1896                    .await
1897            }
1898            DnsUpdater::UltraDns(provider) => {
1899                provider
1900                    .remove_from_rrset(name, record_type, records, origin)
1901                    .await
1902            }
1903            DnsUpdater::Infoblox(provider) => {
1904                provider
1905                    .remove_from_rrset(name, record_type, records, origin)
1906                    .await
1907            }
1908            #[cfg(feature = "test_provider")]
1909            DnsUpdater::Pebble(provider) => {
1910                provider
1911                    .remove_from_rrset(name, record_type, records, origin)
1912                    .await
1913            }
1914            #[cfg(feature = "test_provider")]
1915            DnsUpdater::InMemory(provider) => {
1916                provider
1917                    .remove_from_rrset(name, record_type, records, origin)
1918                    .await
1919            }
1920        }
1921    }
1922
1923    /// List the records of the RRSet at (name, type). Returns an empty Vec when the RRSet does not exist.
1924    pub async fn list_rrset(
1925        &self,
1926        name: impl IntoFqdn<'_>,
1927        record_type: DnsRecordType,
1928        origin: impl IntoFqdn<'_>,
1929    ) -> crate::Result<Vec<DnsRecord>> {
1930        match self {
1931            DnsUpdater::Rfc2136(provider) => provider.list_rrset(name, record_type, origin).await,
1932            DnsUpdater::Cloudflare(provider) => {
1933                provider.list_rrset(name, record_type, origin).await
1934            }
1935            DnsUpdater::DigitalOcean(provider) => {
1936                provider.list_rrset(name, record_type, origin).await
1937            }
1938            DnsUpdater::Desec(provider) => provider.list_rrset(name, record_type, origin).await,
1939            DnsUpdater::Constellix(provider) => {
1940                provider.list_rrset(name, record_type, origin).await
1941            }
1942            DnsUpdater::DnsMadeEasy(provider) => {
1943                provider.list_rrset(name, record_type, origin).await
1944            }
1945            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1946            DnsUpdater::Ovh(provider) => provider.list_rrset(name, record_type, origin).await,
1947            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
1948            DnsUpdater::OracleCloud(provider) => {
1949                provider.list_rrset(name, record_type, origin).await
1950            }
1951            DnsUpdater::Bunny(provider) => provider.list_rrset(name, record_type, origin).await,
1952            DnsUpdater::Linode(provider) => provider.list_rrset(name, record_type, origin).await,
1953            DnsUpdater::Porkbun(provider) => provider.list_rrset(name, record_type, origin).await,
1954            DnsUpdater::Exoscale(provider) => provider.list_rrset(name, record_type, origin).await,
1955            DnsUpdater::Nifcloud(provider) => provider.list_rrset(name, record_type, origin).await,
1956            DnsUpdater::WebSupport(provider) => {
1957                provider.list_rrset(name, record_type, origin).await
1958            }
1959            DnsUpdater::Spaceship(provider) => provider.list_rrset(name, record_type, origin).await,
1960            DnsUpdater::DNSimple(provider) => provider.list_rrset(name, record_type, origin).await,
1961            DnsUpdater::GandiV5(provider) => provider.list_rrset(name, record_type, origin).await,
1962            DnsUpdater::Godaddy(provider) => provider.list_rrset(name, record_type, origin).await,
1963            DnsUpdater::Hetzner(provider) => provider.list_rrset(name, record_type, origin).await,
1964            DnsUpdater::NameDotCom(provider) => {
1965                provider.list_rrset(name, record_type, origin).await
1966            }
1967            DnsUpdater::NameSilo(provider) => provider.list_rrset(name, record_type, origin).await,
1968            DnsUpdater::DuckDns(provider) => provider.list_rrset(name, record_type, origin).await,
1969            DnsUpdater::FreeMyIp(provider) => provider.list_rrset(name, record_type, origin).await,
1970            DnsUpdater::Ipv64(provider) => provider.list_rrset(name, record_type, origin).await,
1971            DnsUpdater::Ddnss(provider) => provider.list_rrset(name, record_type, origin).await,
1972            DnsUpdater::Dynu(provider) => provider.list_rrset(name, record_type, origin).await,
1973            DnsUpdater::GoogleCloudDns(provider) => {
1974                provider.list_rrset(name, record_type, origin).await
1975            }
1976            DnsUpdater::Route53(provider) => provider.list_rrset(name, record_type, origin).await,
1977            DnsUpdater::Vultr(provider) => provider.list_rrset(name, record_type, origin).await,
1978            DnsUpdater::Scaleway(provider) => provider.list_rrset(name, record_type, origin).await,
1979            DnsUpdater::Gcore(provider) => provider.list_rrset(name, record_type, origin).await,
1980            DnsUpdater::Vercel(provider) => provider.list_rrset(name, record_type, origin).await,
1981            DnsUpdater::Ionos(provider) => provider.list_rrset(name, record_type, origin).await,
1982            DnsUpdater::HostingDe(provider) => provider.list_rrset(name, record_type, origin).await,
1983            DnsUpdater::Domeneshop(provider) => {
1984                provider.list_rrset(name, record_type, origin).await
1985            }
1986            DnsUpdater::Safedns(provider) => provider.list_rrset(name, record_type, origin).await,
1987            DnsUpdater::ArvanCloud(provider) => {
1988                provider.list_rrset(name, record_type, origin).await
1989            }
1990            DnsUpdater::Infomaniak(provider) => {
1991                provider.list_rrset(name, record_type, origin).await
1992            }
1993            DnsUpdater::Ns1(provider) => provider.list_rrset(name, record_type, origin).await,
1994            DnsUpdater::LuaDns(provider) => provider.list_rrset(name, record_type, origin).await,
1995            DnsUpdater::Netcup(provider) => provider.list_rrset(name, record_type, origin).await,
1996            DnsUpdater::Netlify(provider) => provider.list_rrset(name, record_type, origin).await,
1997            DnsUpdater::Inwx(provider) => provider.list_rrset(name, record_type, origin).await,
1998            DnsUpdater::Alidns(provider) => provider.list_rrset(name, record_type, origin).await,
1999            DnsUpdater::HuaweiCloud(provider) => {
2000                provider.list_rrset(name, record_type, origin).await
2001            }
2002            DnsUpdater::ClouDns(provider) => provider.list_rrset(name, record_type, origin).await,
2003            DnsUpdater::TencentCloud(provider) => {
2004                provider.list_rrset(name, record_type, origin).await
2005            }
2006            DnsUpdater::BaiduCloud(provider) => {
2007                provider.list_rrset(name, record_type, origin).await
2008            }
2009            DnsUpdater::EasyDns(provider) => provider.list_rrset(name, record_type, origin).await,
2010            DnsUpdater::Joker(provider) => provider.list_rrset(name, record_type, origin).await,
2011            DnsUpdater::MythicBeasts(provider) => {
2012                provider.list_rrset(name, record_type, origin).await
2013            }
2014            DnsUpdater::Namecheap(provider) => provider.list_rrset(name, record_type, origin).await,
2015            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
2016            DnsUpdater::Transip(provider) => provider.list_rrset(name, record_type, origin).await,
2017            DnsUpdater::BluecatV2(provider) => provider.list_rrset(name, record_type, origin).await,
2018            DnsUpdater::Glesys(provider) => provider.list_rrset(name, record_type, origin).await,
2019            DnsUpdater::Dreamhost(provider) => provider.list_rrset(name, record_type, origin).await,
2020            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
2021            DnsUpdater::Volcengine(provider) => {
2022                provider.list_rrset(name, record_type, origin).await
2023            }
2024            #[cfg(any(feature = "ring", feature = "aws-lc-rs"))]
2025            DnsUpdater::YandexCloud(provider) => {
2026                provider.list_rrset(name, record_type, origin).await
2027            }
2028            DnsUpdater::AzureDns(provider) => provider.list_rrset(name, record_type, origin).await,
2029            DnsUpdater::IbmCloud(provider) => provider.list_rrset(name, record_type, origin).await,
2030            DnsUpdater::Hurricane(provider) => provider.list_rrset(name, record_type, origin).await,
2031            DnsUpdater::Hostinger(provider) => provider.list_rrset(name, record_type, origin).await,
2032            DnsUpdater::Autodns(provider) => provider.list_rrset(name, record_type, origin).await,
2033            DnsUpdater::Plesk(provider) => provider.list_rrset(name, record_type, origin).await,
2034            DnsUpdater::Cpanel(provider) => provider.list_rrset(name, record_type, origin).await,
2035            DnsUpdater::Lightsail(provider) => provider.list_rrset(name, record_type, origin).await,
2036            DnsUpdater::EdgeDns(provider) => provider.list_rrset(name, record_type, origin).await,
2037            DnsUpdater::UltraDns(provider) => provider.list_rrset(name, record_type, origin).await,
2038            DnsUpdater::Infoblox(provider) => provider.list_rrset(name, record_type, origin).await,
2039            #[cfg(feature = "test_provider")]
2040            DnsUpdater::Pebble(provider) => provider.list_rrset(name, record_type, origin).await,
2041            #[cfg(feature = "test_provider")]
2042            DnsUpdater::InMemory(provider) => provider.list_rrset(name, record_type, origin).await,
2043        }
2044    }
2045}