From 2c4a504497eb2861a19e24734b143ac8b632ad4b Mon Sep 17 00:00:00 2001 From: Maurus Decimus <11444311+mdecimus@users.noreply.github.com> Date: Mon, 18 May 2026 20:07:08 +0200 Subject: [PATCH] Add 58 new DNS provider integrations --- CHANGELOG.md | 61 +- Cargo.lock | 4 +- crates/common/Cargo.toml | 2 +- crates/common/src/network/dns/update.rs | 888 +- crates/jmap/src/registry/mapping/bootstrap.rs | 63 +- crates/registry/src/schema/enums.rs | 137 +- crates/registry/src/schema/enums_impl.rs | 475 +- crates/registry/src/schema/properties.rs | 35 + crates/registry/src/schema/properties_impl.rs | 225 +- crates/registry/src/schema/structs.rs | 1090 ++- crates/registry/src/schema/structs_impl.rs | 7873 ++++++++++++++++- crates/services/Cargo.toml | 2 +- resources/schema/schema.json.gz | Bin 138964 -> 145720 bytes resources/schema/schema.json.sha256 | 2 +- tests/Cargo.toml | 2 +- tests/src/automation/acme.rs | 6 +- tests/src/automation/dkim.rs | 3 +- tests/src/automation/dns.rs | 3 +- 18 files changed, 10564 insertions(+), 307 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 735bb425..e0912721 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,66 @@ All notable changes to this project will be documented in this file. This projec If you are upgrading from v0.16.x, replace the binary (or run `docker pull`). If you are upgrading from v0.15.x and below, please read the [upgrading documentation](https://github.com/stalwartlabs/stalwart/blob/main/UPGRADING/v0_16.md) for more information on how to upgrade from previous versions. ## Added -- Dns updater: Log DNS record types and values. +- Added 58 new DNS provider integrations: + - Akamai Edge DNS + - Alibaba Cloud DNS + - ArvanCloud + - AutoDNS + - AWS Lightsail + - Azure DNS + - Baidu Cloud DNS + - BlueCat Address Manager + - ClouDNS + - Constellix + - cPanel + - DDNSS.de + - DNS Made Easy + - Domeneshop + - DreamHost + - DuckDNS + - Dynu + - EasyDNS + - Exoscale + - FreeMyIP + - Gandi v5 + - Gcore + - GleSYS + - GoDaddy + - Hetzner DNS + - hosting.de + - Hostinger + - Huawei Cloud DNS + - Hurricane Electric + - IBM Cloud (SoftLayer) + - Infoblox NIOS + - Infomaniak + - INWX + - IONOS + - IPv64 + - Joker + - Linode + - LuaDNS + - Mythic Beasts + - Name.com + - Namecheap + - NameSilo + - netcup + - Netlify + - Nifcloud + - NS1 + - Oracle Cloud DNS + - Plesk + - SafeDNS + - Scaleway + - Tencent Cloud DNSPod + - TransIP + - UltraDNS + - Vercel + - Volcano Engine + - Vultr + - Websupport + - Yandex Cloud DNS +- DNS updater: Log DNS record types and values. ## Changed - Bump JMAP File Storage to [draft-ietf-jmap-filenode-14](https://datatracker.ietf.org/doc/html/draft-ietf-jmap-filenode-14). diff --git a/Cargo.lock b/Cargo.lock index 6e4cd77b..82baed39 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1937,9 +1937,9 @@ dependencies = [ [[package]] name = "dns-update" -version = "0.3.1" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b70617312220ada56e308bf4a2287c942629ce36635204eb18faa74db2470514" +checksum = "2311edba67657d9fe03bea5c2934e75cb63b5e9fdf2dfd6e26e4f9151f762eb3" dependencies = [ "aws-lc-rs", "base64 0.22.1", diff --git a/crates/common/Cargo.toml b/crates/common/Cargo.toml index 365ba3be..855605fd 100644 --- a/crates/common/Cargo.toml +++ b/crates/common/Cargo.toml @@ -20,7 +20,7 @@ mail-parser = { version = "0.11", features = ["full_encoding"] } mail-builder = { version = "0.4" } mail-auth = { version = "0.9", features = ["generate"] } smtp-proto = { version = "0.2", features = ["rkyv"] } -dns-update = { version = "0.3" } +dns-update = { version = "0.4.0" } calcard = { version = "0.3", features = ["rkyv"] } ahash = { version = "0.8.2", features = ["serde"] } parking_lot = "0.12.1" diff --git a/crates/common/src/network/dns/update.rs b/crates/common/src/network/dns/update.rs index 6e896167..d0185465 100644 --- a/crates/common/src/network/dns/update.rs +++ b/crates/common/src/network/dns/update.rs @@ -75,23 +75,19 @@ impl DnsUpdater { ) .map_err(|err| format!("Failed to build DNS updater: {}", err))?, }), - DnsServer::Sig0(_) => { - Err("RFC 2136 with SIG(0) authentication is no longer supported".into()) - } DnsServer::Cloudflare(server) => { let updater = { #[cfg(feature = "test_mode")] - match server.email.as_deref() { - Some("test@pebble.org") => dns_update::DnsUpdater::new_pebble( + match server.secret.secret().await.unwrap().as_ref() { + "test@pebble.org" => dns_update::DnsUpdater::new_pebble( "http://localhost:8055", server.timeout.into_inner().into(), ), - Some("test@memory.org") => { + "test@memory.org" => { dns_update::DnsUpdater::new_in_memory(DNS_RECORDS.clone()) } _ => dns_update::DnsUpdater::new_cloudflare( server.secret.secret().await?, - server.email, server.timeout.into_inner().into(), ) .map_err(|err| format!("Failed to build DNS updater: {}", err))?, @@ -100,7 +96,6 @@ impl DnsUpdater { #[cfg(not(feature = "test_mode"))] dns_update::DnsUpdater::new_cloudflare( server.secret.secret().await?, - server.email, server.timeout.into_inner().into(), ) .map_err(|err| format!("Failed to build DNS updater: {}", err))? @@ -181,7 +176,7 @@ impl DnsUpdater { core, updater: dns_update::DnsUpdater::new_porkbun( server.api_key.as_str(), - server.secret.secret().await?, + server.secret_api_key.secret().await?, server.timeout.into_inner().into(), ) .map_err(|err| format!("Failed to build DNS updater: {}", err))?, @@ -193,7 +188,7 @@ impl DnsUpdater { ttl: server.ttl.into_inner(), core, updater: dns_update::DnsUpdater::new_dnsimple( - server.secret.secret().await?, + server.auth_token.secret().await?, server.account_identifier.as_str(), server.timeout.into_inner().into(), ) @@ -253,6 +248,869 @@ impl DnsUpdater { .map_err(|err| format!("Failed to build DNS updater: {}", err))?, }) } + DnsServer::Alidns(server) => { + let secret_key = server.secret_key.secret().await?.into_owned(); + let security_token = server + .security_token + .secret() + .await? + .map(|c| c.into_owned()); + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_alidns( + server.access_key.as_str(), + secret_key.as_str(), + server.region.as_deref(), + security_token.as_deref(), + server.line.as_deref(), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::ArvanCloud(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_arvancloud( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Autodns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_autodns( + server.username.as_str(), + server.password.secret().await?, + server.context.map(|v| v as u32), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::AzureDns(server) => { + let client_secret = server.client_secret.secret().await?.into_owned(); + let config = dns_update::providers::azuredns::AzureDnsConfig { + tenant_id: server.tenant_id, + client_id: server.client_id, + client_secret, + subscription_id: server.subscription_id, + resource_group: server.resource_group, + environment: match server.environment { + enums::AzureEnvironment::Public => { + dns_update::providers::azuredns::AzureEnvironment::Public + } + enums::AzureEnvironment::China => { + dns_update::providers::azuredns::AzureEnvironment::China + } + enums::AzureEnvironment::UsGovernment => { + dns_update::providers::azuredns::AzureEnvironment::UsGovernment + } + }, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_azuredns(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::BaiduCloud(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_baiducloud( + server.access_key.as_str(), + server.secret_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::BluecatV2(server) => { + let password = server.password.secret().await?.into_owned(); + let config = dns_update::providers::bluecatv2::BluecatV2Config { + server_url: server.base_url, + username: server.username, + password, + config_name: server.config_name, + view_name: server.view_name, + skip_deploy: server.skip_deploy, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_bluecatv2(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::ClouDns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_cloudns( + server.auth_id.as_deref(), + server.sub_auth_id.as_deref(), + server.password.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Constellix(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_constellix( + server.api_key.as_str(), + server.secret_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Cpanel(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_cpanel( + server.base_url.as_str(), + server.username.as_str(), + server.token.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Ddnss(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ddnss( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::DnsMadeEasy(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_dnsmadeeasy( + server.api_key.as_str(), + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Domeneshop(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_domeneshop( + server.auth_token.as_str(), + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Dreamhost(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_dreamhost( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::DuckDns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_duckdns( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Dynu(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_dynu( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::EasyDns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_easydns( + server.token.as_str(), + server.key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::EdgeDns(server) => { + let client_secret = server.client_secret.secret().await?.into_owned(); + let access_token = server.access_token.secret().await?.into_owned(); + let config = dns_update::providers::edgedns::EdgeDnsConfig { + host: server.host, + client_token: server.client_token, + client_secret, + access_token, + account_switch_key: server.account_switch_key, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_edgedns(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Exoscale(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_exoscale( + server.api_key.as_str(), + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::FreeMyIp(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_freemyip( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::GandiV5(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_gandiv5( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Gcore(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_gcore( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Glesys(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_glesys( + server.api_user.as_str(), + server.api_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Godaddy(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_godaddy( + server.api_key.as_str(), + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Hetzner(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_hetzner( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::HostingDe(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_hostingde( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Hostinger(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_hostinger( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::HuaweiCloud(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_huaweicloud( + server.access_key.as_str(), + server.secret_key.secret().await?, + server.region.as_str(), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Hurricane(server) => { + let mut credentials = std::collections::HashMap::new(); + for cred in server.credentials.0.into_values() { + let secret = cred.secret.secret().await?.into_owned(); + credentials.insert(cred.zone, secret); + } + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_hurricane( + credentials, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::IbmCloud(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ibmcloud( + server.username.as_str(), + server.api_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Infoblox(server) => { + let password = server.password.secret().await?.into_owned(); + let config = dns_update::providers::infoblox::InfobloxConfig { + host: server.host, + port: server.port, + username: server.username, + password, + wapi_version: server.wapi_version, + dns_view: server.dns_view, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_infoblox(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Infomaniak(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_infomaniak( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Inwx(server) => { + let password = server.password.secret().await?.into_owned(); + let shared_secret = server.shared_secret.secret().await?.map(|c| c.into_owned()); + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_inwx( + server.username, + password, + shared_secret, + server.sandbox, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Ionos(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ionos( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Ipv64(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ipv64( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Joker(server) => { + let auth = match server.auth { + registry::schema::structs::JokerAuth::ApiKey(api) => { + let key = api.api_key.secret().await?.into_owned(); + dns_update::providers::joker::JokerAuth::api_key(key) + } + registry::schema::structs::JokerAuth::UsernamePassword(creds) => { + let password = creds.password.secret().await?.into_owned(); + dns_update::providers::joker::JokerAuth::username_password( + creds.username, + password, + ) + } + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_joker( + auth, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Lightsail(server) => { + let secret_access_key = server.secret_access_key.secret().await?.into_owned(); + let session_token = server.session_token.secret().await?.map(|c| c.into_owned()); + let config = dns_update::providers::lightsail::LightsailConfig { + access_key_id: server.access_key_id, + secret_access_key, + session_token, + region: server.region, + domain: server.domain, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_lightsail(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Linode(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_linode( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::LuaDns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_luadns( + server.username.as_str(), + server.auth_token.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::MythicBeasts(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_mythicbeasts( + server.username.as_str(), + server.password.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Namecheap(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_namecheap( + server.api_user.as_str(), + server.api_key.secret().await?, + server.client_ip.as_str(), + server.username.as_deref(), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::NameDotCom(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_namedotcom( + server.username.as_str(), + server.auth_token.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::NameSilo(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_namesilo( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Netcup(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_netcup( + server.customer_number.as_str(), + server.api_key.as_str(), + server.password.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Netlify(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_netlify( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Nifcloud(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_nifcloud( + server.access_key.as_str(), + server.secret_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Ns1(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ns1( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::OracleCloud(server) => { + let private_key_pem = server.private_key_pem.secret().await?.into_owned(); + let private_key_password = server + .private_key_password + .secret() + .await? + .map(|c| c.into_owned()); + let config = dns_update::providers::oraclecloud::OracleCloudConfig { + tenancy_ocid: server.tenancy_ocid, + user_ocid: server.user_ocid, + fingerprint: server.fingerprint, + private_key_pem, + private_key_password, + region: server.region, + compartment_ocid: server.compartment_ocid, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_oraclecloud(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Plesk(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_plesk( + server.base_url.as_str(), + server.api_key.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Safedns(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_safedns( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Scaleway(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_scaleway( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::TencentCloud(server) => { + let secret_key = server.secret_key.secret().await?.into_owned(); + let session_token = server.session_token.secret().await?.map(|c| c.into_owned()); + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_tencentcloud( + server.secret_id.as_str(), + secret_key.as_str(), + server.region.as_deref(), + session_token.as_deref(), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Transip(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_transip( + server.username.as_str(), + server.private_key_pem.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::UltraDns(server) => { + let password = server.password.secret().await?.into_owned(); + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_ultradns( + server.username, + password, + server.endpoint, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Vercel(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_vercel( + server.auth_token.secret().await?, + server.team_id.as_deref(), + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::Volcengine(server) => { + let secret_key = server.secret_key.secret().await?.into_owned(); + let config = dns_update::providers::volcengine::VolcengineConfig { + access_key: server.access_key, + secret_key, + region: server.region, + host: server.host, + scheme: server.scheme, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_volcengine(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Vultr(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_vultr( + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::WebSupport(server) => Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_websupport( + server.api_key.as_str(), + server.secret.secret().await?, + server.timeout.into_inner().into(), + ) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }), + DnsServer::YandexCloud(server) => { + let iam_token_b64 = server.api_key.secret().await?.into_owned(); + let config = dns_update::providers::yandexcloud::YandexCloudConfig { + iam_token_b64, + folder_id: server.folder_id, + request_timeout: Some(server.timeout.into_inner()), + }; + Ok(DnsUpdater { + polling_interval: server.polling_interval.into_inner(), + propagation_timeout: server.propagation_timeout.into_inner(), + propagation_delay: server.propagation_delay.map(|d| d.into_inner()), + ttl: server.ttl.into_inner(), + core, + updater: dns_update::DnsUpdater::new_yandexcloud(config) + .map_err(|err| format!("Failed to build DNS updater: {}", err))?, + }) + } + DnsServer::Deprecated1 => Err("DNS server type no longer supported".to_string()), } } @@ -292,7 +1150,7 @@ impl DnsUpdater { Hostname = name.to_string(), Details = origin.to_string(), Type = record.as_type().as_str(), - Value = format!("{:?}", record), + Value = record.to_string(), ); if verify && let DnsRecord::TXT(txt_record) = &record { @@ -324,7 +1182,7 @@ impl DnsUpdater { Details = origin.to_string(), Result = result.to_string(), Type = record.as_type().as_str(), - Value = format!("{:?}", record), + Value = record.to_string(), ); } } @@ -335,7 +1193,7 @@ impl DnsUpdater { Details = origin.to_string(), Reason = err.to_string(), Type = record.as_type().as_str(), - Value = format!("{:?}", record), + Value = record.to_string(), ); } } @@ -349,7 +1207,7 @@ impl DnsUpdater { Hostname = name.to_string(), Details = origin.to_string(), Type = record.as_type().as_str(), - Value = format!("{:?}", record), + Value = record.to_string(), ); } else { trc::event!( @@ -357,7 +1215,7 @@ impl DnsUpdater { Hostname = name.to_string(), Details = origin.to_string(), Type = record.as_type().as_str(), - Value = format!("{:?}", record), + Value = record.to_string(), ); } diff --git a/crates/jmap/src/registry/mapping/bootstrap.rs b/crates/jmap/src/registry/mapping/bootstrap.rs index c00a4244..06f7ff50 100644 --- a/crates/jmap/src/registry/mapping/bootstrap.rs +++ b/crates/jmap/src/registry/mapping/bootstrap.rs @@ -543,13 +543,10 @@ fn map_directory(directory: &DirectoryBootstrap) -> Option { fn map_dns_server(dns_server: &DnsServerBootstrap) -> Option { match dns_server { - DnsServerBootstrap::Manual => None, + DnsServerBootstrap::Manual | DnsServerBootstrap::Deprecated1 => None, DnsServerBootstrap::Tsig(dns_server_tsig) => { DnsServer::Tsig(dns_server_tsig.clone()).into() } - DnsServerBootstrap::Sig0(dns_server_sig0) => { - DnsServer::Sig0(dns_server_sig0.clone()).into() - } DnsServerBootstrap::Cloudflare(dns_server_cloudflare) => { DnsServer::Cloudflare(dns_server_cloudflare.clone()).into() } @@ -578,6 +575,64 @@ fn map_dns_server(dns_server: &DnsServerBootstrap) -> Option { DnsServer::GoogleCloudDns(dns_server_google_cloud_dns.clone()).into() } + DnsServerBootstrap::Alidns(inner) => DnsServer::Alidns(inner.clone()).into(), + DnsServerBootstrap::ArvanCloud(inner) => DnsServer::ArvanCloud(inner.clone()).into(), + DnsServerBootstrap::Autodns(inner) => DnsServer::Autodns(inner.clone()).into(), + DnsServerBootstrap::AzureDns(inner) => DnsServer::AzureDns(inner.clone()).into(), + DnsServerBootstrap::BaiduCloud(inner) => DnsServer::BaiduCloud(inner.clone()).into(), + DnsServerBootstrap::BluecatV2(inner) => DnsServer::BluecatV2(inner.clone()).into(), + DnsServerBootstrap::ClouDns(inner) => DnsServer::ClouDns(inner.clone()).into(), + DnsServerBootstrap::Constellix(inner) => DnsServer::Constellix(inner.clone()).into(), + DnsServerBootstrap::Cpanel(inner) => DnsServer::Cpanel(inner.clone()).into(), + DnsServerBootstrap::Ddnss(inner) => DnsServer::Ddnss(inner.clone()).into(), + DnsServerBootstrap::DnsMadeEasy(inner) => DnsServer::DnsMadeEasy(inner.clone()).into(), + DnsServerBootstrap::Domeneshop(inner) => DnsServer::Domeneshop(inner.clone()).into(), + DnsServerBootstrap::Dreamhost(inner) => DnsServer::Dreamhost(inner.clone()).into(), + DnsServerBootstrap::DuckDns(inner) => DnsServer::DuckDns(inner.clone()).into(), + DnsServerBootstrap::Dynu(inner) => DnsServer::Dynu(inner.clone()).into(), + DnsServerBootstrap::EasyDns(inner) => DnsServer::EasyDns(inner.clone()).into(), + DnsServerBootstrap::EdgeDns(inner) => DnsServer::EdgeDns(inner.clone()).into(), + DnsServerBootstrap::Exoscale(inner) => DnsServer::Exoscale(inner.clone()).into(), + DnsServerBootstrap::FreeMyIp(inner) => DnsServer::FreeMyIp(inner.clone()).into(), + DnsServerBootstrap::GandiV5(inner) => DnsServer::GandiV5(inner.clone()).into(), + DnsServerBootstrap::Gcore(inner) => DnsServer::Gcore(inner.clone()).into(), + DnsServerBootstrap::Glesys(inner) => DnsServer::Glesys(inner.clone()).into(), + DnsServerBootstrap::Godaddy(inner) => DnsServer::Godaddy(inner.clone()).into(), + DnsServerBootstrap::Hetzner(inner) => DnsServer::Hetzner(inner.clone()).into(), + DnsServerBootstrap::HostingDe(inner) => DnsServer::HostingDe(inner.clone()).into(), + DnsServerBootstrap::Hostinger(inner) => DnsServer::Hostinger(inner.clone()).into(), + DnsServerBootstrap::HuaweiCloud(inner) => DnsServer::HuaweiCloud(inner.clone()).into(), + DnsServerBootstrap::Hurricane(inner) => DnsServer::Hurricane(inner.clone()).into(), + DnsServerBootstrap::IbmCloud(inner) => DnsServer::IbmCloud(inner.clone()).into(), + DnsServerBootstrap::Infoblox(inner) => DnsServer::Infoblox(inner.clone()).into(), + DnsServerBootstrap::Infomaniak(inner) => DnsServer::Infomaniak(inner.clone()).into(), + DnsServerBootstrap::Inwx(inner) => DnsServer::Inwx(inner.clone()).into(), + DnsServerBootstrap::Ionos(inner) => DnsServer::Ionos(inner.clone()).into(), + DnsServerBootstrap::Ipv64(inner) => DnsServer::Ipv64(inner.clone()).into(), + DnsServerBootstrap::Joker(inner) => DnsServer::Joker(inner.clone()).into(), + DnsServerBootstrap::Lightsail(inner) => DnsServer::Lightsail(inner.clone()).into(), + DnsServerBootstrap::Linode(inner) => DnsServer::Linode(inner.clone()).into(), + DnsServerBootstrap::LuaDns(inner) => DnsServer::LuaDns(inner.clone()).into(), + DnsServerBootstrap::MythicBeasts(inner) => DnsServer::MythicBeasts(inner.clone()).into(), + DnsServerBootstrap::Namecheap(inner) => DnsServer::Namecheap(inner.clone()).into(), + DnsServerBootstrap::NameDotCom(inner) => DnsServer::NameDotCom(inner.clone()).into(), + DnsServerBootstrap::NameSilo(inner) => DnsServer::NameSilo(inner.clone()).into(), + DnsServerBootstrap::Netcup(inner) => DnsServer::Netcup(inner.clone()).into(), + DnsServerBootstrap::Netlify(inner) => DnsServer::Netlify(inner.clone()).into(), + DnsServerBootstrap::Nifcloud(inner) => DnsServer::Nifcloud(inner.clone()).into(), + DnsServerBootstrap::Ns1(inner) => DnsServer::Ns1(inner.clone()).into(), + DnsServerBootstrap::OracleCloud(inner) => DnsServer::OracleCloud(inner.clone()).into(), + DnsServerBootstrap::Plesk(inner) => DnsServer::Plesk(inner.clone()).into(), + DnsServerBootstrap::Safedns(inner) => DnsServer::Safedns(inner.clone()).into(), + DnsServerBootstrap::Scaleway(inner) => DnsServer::Scaleway(inner.clone()).into(), + DnsServerBootstrap::TencentCloud(inner) => DnsServer::TencentCloud(inner.clone()).into(), + DnsServerBootstrap::Transip(inner) => DnsServer::Transip(inner.clone()).into(), + DnsServerBootstrap::UltraDns(inner) => DnsServer::UltraDns(inner.clone()).into(), + DnsServerBootstrap::Vercel(inner) => DnsServer::Vercel(inner.clone()).into(), + DnsServerBootstrap::Volcengine(inner) => DnsServer::Volcengine(inner.clone()).into(), + DnsServerBootstrap::Vultr(inner) => DnsServer::Vultr(inner.clone()).into(), + DnsServerBootstrap::WebSupport(inner) => DnsServer::WebSupport(inner.clone()).into(), + DnsServerBootstrap::YandexCloud(inner) => DnsServer::YandexCloud(inner.clone()).into(), } } diff --git a/crates/registry/src/schema/enums.rs b/crates/registry/src/schema/enums.rs index 28f2743c..a311b330 100644 --- a/crates/registry/src/schema/enums.rs +++ b/crates/registry/src/schema/enums.rs @@ -151,6 +151,15 @@ pub enum AsnType { Dns = 2, } +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] +#[repr(u16)] +pub enum AzureEnvironment { + #[default] + Public = 0, + China = 1, + UsGovernment = 2, +} + #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] #[repr(u16)] pub enum BlobStoreBaseType { @@ -518,7 +527,7 @@ pub enum DnsServerBootstrapType { #[default] Manual = 0, Tsig = 1, - Sig0 = 2, + Deprecated1 = 2, Cloudflare = 3, DigitalOcean = 4, DeSEC = 5, @@ -529,6 +538,64 @@ pub enum DnsServerBootstrapType { Spaceship = 10, Route53 = 11, GoogleCloudDns = 12, + Alidns = 13, + ArvanCloud = 14, + Autodns = 15, + AzureDns = 16, + BaiduCloud = 17, + BluecatV2 = 18, + ClouDns = 19, + Constellix = 20, + Cpanel = 21, + Ddnss = 22, + DnsMadeEasy = 23, + Domeneshop = 24, + Dreamhost = 25, + DuckDns = 26, + Dynu = 27, + EasyDns = 28, + EdgeDns = 29, + Exoscale = 30, + FreeMyIp = 31, + GandiV5 = 32, + Gcore = 33, + Glesys = 34, + Godaddy = 35, + Hetzner = 36, + HostingDe = 37, + Hostinger = 38, + HuaweiCloud = 39, + Hurricane = 40, + IbmCloud = 41, + Infoblox = 42, + Infomaniak = 43, + Inwx = 44, + Ionos = 45, + Ipv64 = 46, + Joker = 47, + Lightsail = 48, + Linode = 49, + LuaDns = 50, + MythicBeasts = 51, + Namecheap = 52, + NameDotCom = 53, + NameSilo = 54, + Netcup = 55, + Netlify = 56, + Nifcloud = 57, + Ns1 = 58, + OracleCloud = 59, + Plesk = 60, + Safedns = 61, + Scaleway = 62, + TencentCloud = 63, + Transip = 64, + UltraDns = 65, + Vercel = 66, + Volcengine = 67, + Vultr = 68, + WebSupport = 69, + YandexCloud = 70, } #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] @@ -536,7 +603,7 @@ pub enum DnsServerBootstrapType { pub enum DnsServerType { #[default] Tsig = 0, - Sig0 = 1, + Deprecated1 = 1, Cloudflare = 2, DigitalOcean = 3, DeSEC = 4, @@ -547,6 +614,64 @@ pub enum DnsServerType { Spaceship = 9, Route53 = 10, GoogleCloudDns = 11, + Alidns = 12, + ArvanCloud = 13, + Autodns = 14, + AzureDns = 15, + BaiduCloud = 16, + BluecatV2 = 17, + ClouDns = 18, + Constellix = 19, + Cpanel = 20, + Ddnss = 21, + DnsMadeEasy = 22, + Domeneshop = 23, + Dreamhost = 24, + DuckDns = 25, + Dynu = 26, + EasyDns = 27, + EdgeDns = 28, + Exoscale = 29, + FreeMyIp = 30, + GandiV5 = 31, + Gcore = 32, + Glesys = 33, + Godaddy = 34, + Hetzner = 35, + HostingDe = 36, + Hostinger = 37, + HuaweiCloud = 38, + Hurricane = 39, + IbmCloud = 40, + Infoblox = 41, + Infomaniak = 42, + Inwx = 43, + Ionos = 44, + Ipv64 = 45, + Joker = 46, + Lightsail = 47, + Linode = 48, + LuaDns = 49, + MythicBeasts = 50, + Namecheap = 51, + NameDotCom = 52, + NameSilo = 53, + Netcup = 54, + Netlify = 55, + Nifcloud = 56, + Ns1 = 57, + OracleCloud = 58, + Plesk = 59, + Safedns = 60, + Scaleway = 61, + TencentCloud = 62, + Transip = 63, + UltraDns = 64, + Vercel = 65, + Volcengine = 66, + Vultr = 67, + WebSupport = 68, + YandexCloud = 69, } #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] @@ -751,6 +876,14 @@ pub enum IpProtocol { Tcp = 1, } +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] +#[repr(u16)] +pub enum JokerAuthType { + #[default] + ApiKey = 0, + UsernamePassword = 1, +} + #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)] #[repr(u16)] pub enum JwtSignatureAlgorithm { diff --git a/crates/registry/src/schema/enums_impl.rs b/crates/registry/src/schema/enums_impl.rs index f6ce64aa..72ac8ca4 100644 --- a/crates/registry/src/schema/enums_impl.rs +++ b/crates/registry/src/schema/enums_impl.rs @@ -807,6 +807,59 @@ impl<'de> serde::Deserialize<'de> for AsnType { } } +impl EnumImpl for AzureEnvironment { + fn parse(value: &str) -> Option { + hashify::tiny_map! { + value.as_bytes(), + b"public" => AzureEnvironment::Public, + b"china" => AzureEnvironment::China, + b"us-government" => AzureEnvironment::UsGovernment, + } + } + + fn as_str(&self) -> &'static str { + match self { + AzureEnvironment::Public => "public", + AzureEnvironment::China => "china", + AzureEnvironment::UsGovernment => "us-government", + } + } + + fn to_id(&self) -> u16 { + *self as u16 + } + + fn from_id(id: u16) -> Option { + match id { + 0 => Some(AzureEnvironment::Public), + 1 => Some(AzureEnvironment::China), + 2 => Some(AzureEnvironment::UsGovernment), + _ => None, + } + } + + const COUNT: usize = 3; +} + +impl serde::Serialize for AzureEnvironment { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer, + { + serializer.serialize_str(self.as_str()) + } +} + +impl<'de> serde::Deserialize<'de> for AzureEnvironment { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let s = Cow::::deserialize(deserializer)?; + Self::parse(&s).ok_or_else(|| serde::de::Error::unknown_variant(&s, &[])) + } +} + impl EnumImpl for BlobStoreBaseType { fn parse(value: &str) -> Option { hashify::tiny_map! { @@ -2776,11 +2829,12 @@ impl<'de> serde::Deserialize<'de> for DnsResolverType { impl EnumImpl for DnsServerBootstrapType { fn parse(value: &str) -> Option { - hashify::tiny_map! { + hashify::map! { value.as_bytes(), + DnsServerBootstrapType, b"Manual" => DnsServerBootstrapType::Manual, b"Tsig" => DnsServerBootstrapType::Tsig, - b"Sig0" => DnsServerBootstrapType::Sig0, + b"Deprecated1" => DnsServerBootstrapType::Deprecated1, b"Cloudflare" => DnsServerBootstrapType::Cloudflare, b"DigitalOcean" => DnsServerBootstrapType::DigitalOcean, b"DeSEC" => DnsServerBootstrapType::DeSEC, @@ -2791,14 +2845,73 @@ impl EnumImpl for DnsServerBootstrapType { b"Spaceship" => DnsServerBootstrapType::Spaceship, b"Route53" => DnsServerBootstrapType::Route53, b"GoogleCloudDns" => DnsServerBootstrapType::GoogleCloudDns, + b"Alidns" => DnsServerBootstrapType::Alidns, + b"ArvanCloud" => DnsServerBootstrapType::ArvanCloud, + b"Autodns" => DnsServerBootstrapType::Autodns, + b"AzureDns" => DnsServerBootstrapType::AzureDns, + b"BaiduCloud" => DnsServerBootstrapType::BaiduCloud, + b"BluecatV2" => DnsServerBootstrapType::BluecatV2, + b"ClouDns" => DnsServerBootstrapType::ClouDns, + b"Constellix" => DnsServerBootstrapType::Constellix, + b"Cpanel" => DnsServerBootstrapType::Cpanel, + b"Ddnss" => DnsServerBootstrapType::Ddnss, + b"DnsMadeEasy" => DnsServerBootstrapType::DnsMadeEasy, + b"Domeneshop" => DnsServerBootstrapType::Domeneshop, + b"Dreamhost" => DnsServerBootstrapType::Dreamhost, + b"DuckDns" => DnsServerBootstrapType::DuckDns, + b"Dynu" => DnsServerBootstrapType::Dynu, + b"EasyDns" => DnsServerBootstrapType::EasyDns, + b"EdgeDns" => DnsServerBootstrapType::EdgeDns, + b"Exoscale" => DnsServerBootstrapType::Exoscale, + b"FreeMyIp" => DnsServerBootstrapType::FreeMyIp, + b"GandiV5" => DnsServerBootstrapType::GandiV5, + b"Gcore" => DnsServerBootstrapType::Gcore, + b"Glesys" => DnsServerBootstrapType::Glesys, + b"Godaddy" => DnsServerBootstrapType::Godaddy, + b"Hetzner" => DnsServerBootstrapType::Hetzner, + b"HostingDe" => DnsServerBootstrapType::HostingDe, + b"Hostinger" => DnsServerBootstrapType::Hostinger, + b"HuaweiCloud" => DnsServerBootstrapType::HuaweiCloud, + b"Hurricane" => DnsServerBootstrapType::Hurricane, + b"IbmCloud" => DnsServerBootstrapType::IbmCloud, + b"Infoblox" => DnsServerBootstrapType::Infoblox, + b"Infomaniak" => DnsServerBootstrapType::Infomaniak, + b"Inwx" => DnsServerBootstrapType::Inwx, + b"Ionos" => DnsServerBootstrapType::Ionos, + b"Ipv64" => DnsServerBootstrapType::Ipv64, + b"Joker" => DnsServerBootstrapType::Joker, + b"Lightsail" => DnsServerBootstrapType::Lightsail, + b"Linode" => DnsServerBootstrapType::Linode, + b"LuaDns" => DnsServerBootstrapType::LuaDns, + b"MythicBeasts" => DnsServerBootstrapType::MythicBeasts, + b"Namecheap" => DnsServerBootstrapType::Namecheap, + b"NameDotCom" => DnsServerBootstrapType::NameDotCom, + b"NameSilo" => DnsServerBootstrapType::NameSilo, + b"Netcup" => DnsServerBootstrapType::Netcup, + b"Netlify" => DnsServerBootstrapType::Netlify, + b"Nifcloud" => DnsServerBootstrapType::Nifcloud, + b"Ns1" => DnsServerBootstrapType::Ns1, + b"OracleCloud" => DnsServerBootstrapType::OracleCloud, + b"Plesk" => DnsServerBootstrapType::Plesk, + b"Safedns" => DnsServerBootstrapType::Safedns, + b"Scaleway" => DnsServerBootstrapType::Scaleway, + b"TencentCloud" => DnsServerBootstrapType::TencentCloud, + b"Transip" => DnsServerBootstrapType::Transip, + b"UltraDns" => DnsServerBootstrapType::UltraDns, + b"Vercel" => DnsServerBootstrapType::Vercel, + b"Volcengine" => DnsServerBootstrapType::Volcengine, + b"Vultr" => DnsServerBootstrapType::Vultr, + b"WebSupport" => DnsServerBootstrapType::WebSupport, + b"YandexCloud" => DnsServerBootstrapType::YandexCloud, } + .copied() } fn as_str(&self) -> &'static str { match self { DnsServerBootstrapType::Manual => "Manual", DnsServerBootstrapType::Tsig => "Tsig", - DnsServerBootstrapType::Sig0 => "Sig0", + DnsServerBootstrapType::Deprecated1 => "Deprecated1", DnsServerBootstrapType::Cloudflare => "Cloudflare", DnsServerBootstrapType::DigitalOcean => "DigitalOcean", DnsServerBootstrapType::DeSEC => "DeSEC", @@ -2809,6 +2922,64 @@ impl EnumImpl for DnsServerBootstrapType { DnsServerBootstrapType::Spaceship => "Spaceship", DnsServerBootstrapType::Route53 => "Route53", DnsServerBootstrapType::GoogleCloudDns => "GoogleCloudDns", + DnsServerBootstrapType::Alidns => "Alidns", + DnsServerBootstrapType::ArvanCloud => "ArvanCloud", + DnsServerBootstrapType::Autodns => "Autodns", + DnsServerBootstrapType::AzureDns => "AzureDns", + DnsServerBootstrapType::BaiduCloud => "BaiduCloud", + DnsServerBootstrapType::BluecatV2 => "BluecatV2", + DnsServerBootstrapType::ClouDns => "ClouDns", + DnsServerBootstrapType::Constellix => "Constellix", + DnsServerBootstrapType::Cpanel => "Cpanel", + DnsServerBootstrapType::Ddnss => "Ddnss", + DnsServerBootstrapType::DnsMadeEasy => "DnsMadeEasy", + DnsServerBootstrapType::Domeneshop => "Domeneshop", + DnsServerBootstrapType::Dreamhost => "Dreamhost", + DnsServerBootstrapType::DuckDns => "DuckDns", + DnsServerBootstrapType::Dynu => "Dynu", + DnsServerBootstrapType::EasyDns => "EasyDns", + DnsServerBootstrapType::EdgeDns => "EdgeDns", + DnsServerBootstrapType::Exoscale => "Exoscale", + DnsServerBootstrapType::FreeMyIp => "FreeMyIp", + DnsServerBootstrapType::GandiV5 => "GandiV5", + DnsServerBootstrapType::Gcore => "Gcore", + DnsServerBootstrapType::Glesys => "Glesys", + DnsServerBootstrapType::Godaddy => "Godaddy", + DnsServerBootstrapType::Hetzner => "Hetzner", + DnsServerBootstrapType::HostingDe => "HostingDe", + DnsServerBootstrapType::Hostinger => "Hostinger", + DnsServerBootstrapType::HuaweiCloud => "HuaweiCloud", + DnsServerBootstrapType::Hurricane => "Hurricane", + DnsServerBootstrapType::IbmCloud => "IbmCloud", + DnsServerBootstrapType::Infoblox => "Infoblox", + DnsServerBootstrapType::Infomaniak => "Infomaniak", + DnsServerBootstrapType::Inwx => "Inwx", + DnsServerBootstrapType::Ionos => "Ionos", + DnsServerBootstrapType::Ipv64 => "Ipv64", + DnsServerBootstrapType::Joker => "Joker", + DnsServerBootstrapType::Lightsail => "Lightsail", + DnsServerBootstrapType::Linode => "Linode", + DnsServerBootstrapType::LuaDns => "LuaDns", + DnsServerBootstrapType::MythicBeasts => "MythicBeasts", + DnsServerBootstrapType::Namecheap => "Namecheap", + DnsServerBootstrapType::NameDotCom => "NameDotCom", + DnsServerBootstrapType::NameSilo => "NameSilo", + DnsServerBootstrapType::Netcup => "Netcup", + DnsServerBootstrapType::Netlify => "Netlify", + DnsServerBootstrapType::Nifcloud => "Nifcloud", + DnsServerBootstrapType::Ns1 => "Ns1", + DnsServerBootstrapType::OracleCloud => "OracleCloud", + DnsServerBootstrapType::Plesk => "Plesk", + DnsServerBootstrapType::Safedns => "Safedns", + DnsServerBootstrapType::Scaleway => "Scaleway", + DnsServerBootstrapType::TencentCloud => "TencentCloud", + DnsServerBootstrapType::Transip => "Transip", + DnsServerBootstrapType::UltraDns => "UltraDns", + DnsServerBootstrapType::Vercel => "Vercel", + DnsServerBootstrapType::Volcengine => "Volcengine", + DnsServerBootstrapType::Vultr => "Vultr", + DnsServerBootstrapType::WebSupport => "WebSupport", + DnsServerBootstrapType::YandexCloud => "YandexCloud", } } @@ -2820,7 +2991,7 @@ impl EnumImpl for DnsServerBootstrapType { match id { 0 => Some(DnsServerBootstrapType::Manual), 1 => Some(DnsServerBootstrapType::Tsig), - 2 => Some(DnsServerBootstrapType::Sig0), + 2 => Some(DnsServerBootstrapType::Deprecated1), 3 => Some(DnsServerBootstrapType::Cloudflare), 4 => Some(DnsServerBootstrapType::DigitalOcean), 5 => Some(DnsServerBootstrapType::DeSEC), @@ -2831,11 +3002,69 @@ impl EnumImpl for DnsServerBootstrapType { 10 => Some(DnsServerBootstrapType::Spaceship), 11 => Some(DnsServerBootstrapType::Route53), 12 => Some(DnsServerBootstrapType::GoogleCloudDns), + 13 => Some(DnsServerBootstrapType::Alidns), + 14 => Some(DnsServerBootstrapType::ArvanCloud), + 15 => Some(DnsServerBootstrapType::Autodns), + 16 => Some(DnsServerBootstrapType::AzureDns), + 17 => Some(DnsServerBootstrapType::BaiduCloud), + 18 => Some(DnsServerBootstrapType::BluecatV2), + 19 => Some(DnsServerBootstrapType::ClouDns), + 20 => Some(DnsServerBootstrapType::Constellix), + 21 => Some(DnsServerBootstrapType::Cpanel), + 22 => Some(DnsServerBootstrapType::Ddnss), + 23 => Some(DnsServerBootstrapType::DnsMadeEasy), + 24 => Some(DnsServerBootstrapType::Domeneshop), + 25 => Some(DnsServerBootstrapType::Dreamhost), + 26 => Some(DnsServerBootstrapType::DuckDns), + 27 => Some(DnsServerBootstrapType::Dynu), + 28 => Some(DnsServerBootstrapType::EasyDns), + 29 => Some(DnsServerBootstrapType::EdgeDns), + 30 => Some(DnsServerBootstrapType::Exoscale), + 31 => Some(DnsServerBootstrapType::FreeMyIp), + 32 => Some(DnsServerBootstrapType::GandiV5), + 33 => Some(DnsServerBootstrapType::Gcore), + 34 => Some(DnsServerBootstrapType::Glesys), + 35 => Some(DnsServerBootstrapType::Godaddy), + 36 => Some(DnsServerBootstrapType::Hetzner), + 37 => Some(DnsServerBootstrapType::HostingDe), + 38 => Some(DnsServerBootstrapType::Hostinger), + 39 => Some(DnsServerBootstrapType::HuaweiCloud), + 40 => Some(DnsServerBootstrapType::Hurricane), + 41 => Some(DnsServerBootstrapType::IbmCloud), + 42 => Some(DnsServerBootstrapType::Infoblox), + 43 => Some(DnsServerBootstrapType::Infomaniak), + 44 => Some(DnsServerBootstrapType::Inwx), + 45 => Some(DnsServerBootstrapType::Ionos), + 46 => Some(DnsServerBootstrapType::Ipv64), + 47 => Some(DnsServerBootstrapType::Joker), + 48 => Some(DnsServerBootstrapType::Lightsail), + 49 => Some(DnsServerBootstrapType::Linode), + 50 => Some(DnsServerBootstrapType::LuaDns), + 51 => Some(DnsServerBootstrapType::MythicBeasts), + 52 => Some(DnsServerBootstrapType::Namecheap), + 53 => Some(DnsServerBootstrapType::NameDotCom), + 54 => Some(DnsServerBootstrapType::NameSilo), + 55 => Some(DnsServerBootstrapType::Netcup), + 56 => Some(DnsServerBootstrapType::Netlify), + 57 => Some(DnsServerBootstrapType::Nifcloud), + 58 => Some(DnsServerBootstrapType::Ns1), + 59 => Some(DnsServerBootstrapType::OracleCloud), + 60 => Some(DnsServerBootstrapType::Plesk), + 61 => Some(DnsServerBootstrapType::Safedns), + 62 => Some(DnsServerBootstrapType::Scaleway), + 63 => Some(DnsServerBootstrapType::TencentCloud), + 64 => Some(DnsServerBootstrapType::Transip), + 65 => Some(DnsServerBootstrapType::UltraDns), + 66 => Some(DnsServerBootstrapType::Vercel), + 67 => Some(DnsServerBootstrapType::Volcengine), + 68 => Some(DnsServerBootstrapType::Vultr), + 69 => Some(DnsServerBootstrapType::WebSupport), + 70 => Some(DnsServerBootstrapType::YandexCloud), _ => None, } } - const COUNT: usize = 13; + const COUNT: usize = 71; } impl serde::Serialize for DnsServerBootstrapType { @@ -2859,10 +3088,11 @@ impl<'de> serde::Deserialize<'de> for DnsServerBootstrapType { impl EnumImpl for DnsServerType { fn parse(value: &str) -> Option { - hashify::tiny_map! { + hashify::map! { value.as_bytes(), + DnsServerType, b"Tsig" => DnsServerType::Tsig, - b"Sig0" => DnsServerType::Sig0, + b"Deprecated1" => DnsServerType::Deprecated1, b"Cloudflare" => DnsServerType::Cloudflare, b"DigitalOcean" => DnsServerType::DigitalOcean, b"DeSEC" => DnsServerType::DeSEC, @@ -2873,13 +3103,72 @@ impl EnumImpl for DnsServerType { b"Spaceship" => DnsServerType::Spaceship, b"Route53" => DnsServerType::Route53, b"GoogleCloudDns" => DnsServerType::GoogleCloudDns, + b"Alidns" => DnsServerType::Alidns, + b"ArvanCloud" => DnsServerType::ArvanCloud, + b"Autodns" => DnsServerType::Autodns, + b"AzureDns" => DnsServerType::AzureDns, + b"BaiduCloud" => DnsServerType::BaiduCloud, + b"BluecatV2" => DnsServerType::BluecatV2, + b"ClouDns" => DnsServerType::ClouDns, + b"Constellix" => DnsServerType::Constellix, + b"Cpanel" => DnsServerType::Cpanel, + b"Ddnss" => DnsServerType::Ddnss, + b"DnsMadeEasy" => DnsServerType::DnsMadeEasy, + b"Domeneshop" => DnsServerType::Domeneshop, + b"Dreamhost" => DnsServerType::Dreamhost, + b"DuckDns" => DnsServerType::DuckDns, + b"Dynu" => DnsServerType::Dynu, + b"EasyDns" => DnsServerType::EasyDns, + b"EdgeDns" => DnsServerType::EdgeDns, + b"Exoscale" => DnsServerType::Exoscale, + b"FreeMyIp" => DnsServerType::FreeMyIp, + b"GandiV5" => DnsServerType::GandiV5, + b"Gcore" => DnsServerType::Gcore, + b"Glesys" => DnsServerType::Glesys, + b"Godaddy" => DnsServerType::Godaddy, + b"Hetzner" => DnsServerType::Hetzner, + b"HostingDe" => DnsServerType::HostingDe, + b"Hostinger" => DnsServerType::Hostinger, + b"HuaweiCloud" => DnsServerType::HuaweiCloud, + b"Hurricane" => DnsServerType::Hurricane, + b"IbmCloud" => DnsServerType::IbmCloud, + b"Infoblox" => DnsServerType::Infoblox, + b"Infomaniak" => DnsServerType::Infomaniak, + b"Inwx" => DnsServerType::Inwx, + b"Ionos" => DnsServerType::Ionos, + b"Ipv64" => DnsServerType::Ipv64, + b"Joker" => DnsServerType::Joker, + b"Lightsail" => DnsServerType::Lightsail, + b"Linode" => DnsServerType::Linode, + b"LuaDns" => DnsServerType::LuaDns, + b"MythicBeasts" => DnsServerType::MythicBeasts, + b"Namecheap" => DnsServerType::Namecheap, + b"NameDotCom" => DnsServerType::NameDotCom, + b"NameSilo" => DnsServerType::NameSilo, + b"Netcup" => DnsServerType::Netcup, + b"Netlify" => DnsServerType::Netlify, + b"Nifcloud" => DnsServerType::Nifcloud, + b"Ns1" => DnsServerType::Ns1, + b"OracleCloud" => DnsServerType::OracleCloud, + b"Plesk" => DnsServerType::Plesk, + b"Safedns" => DnsServerType::Safedns, + b"Scaleway" => DnsServerType::Scaleway, + b"TencentCloud" => DnsServerType::TencentCloud, + b"Transip" => DnsServerType::Transip, + b"UltraDns" => DnsServerType::UltraDns, + b"Vercel" => DnsServerType::Vercel, + b"Volcengine" => DnsServerType::Volcengine, + b"Vultr" => DnsServerType::Vultr, + b"WebSupport" => DnsServerType::WebSupport, + b"YandexCloud" => DnsServerType::YandexCloud, } + .copied() } fn as_str(&self) -> &'static str { match self { DnsServerType::Tsig => "Tsig", - DnsServerType::Sig0 => "Sig0", + DnsServerType::Deprecated1 => "Deprecated1", DnsServerType::Cloudflare => "Cloudflare", DnsServerType::DigitalOcean => "DigitalOcean", DnsServerType::DeSEC => "DeSEC", @@ -2890,6 +3179,64 @@ impl EnumImpl for DnsServerType { DnsServerType::Spaceship => "Spaceship", DnsServerType::Route53 => "Route53", DnsServerType::GoogleCloudDns => "GoogleCloudDns", + DnsServerType::Alidns => "Alidns", + DnsServerType::ArvanCloud => "ArvanCloud", + DnsServerType::Autodns => "Autodns", + DnsServerType::AzureDns => "AzureDns", + DnsServerType::BaiduCloud => "BaiduCloud", + DnsServerType::BluecatV2 => "BluecatV2", + DnsServerType::ClouDns => "ClouDns", + DnsServerType::Constellix => "Constellix", + DnsServerType::Cpanel => "Cpanel", + DnsServerType::Ddnss => "Ddnss", + DnsServerType::DnsMadeEasy => "DnsMadeEasy", + DnsServerType::Domeneshop => "Domeneshop", + DnsServerType::Dreamhost => "Dreamhost", + DnsServerType::DuckDns => "DuckDns", + DnsServerType::Dynu => "Dynu", + DnsServerType::EasyDns => "EasyDns", + DnsServerType::EdgeDns => "EdgeDns", + DnsServerType::Exoscale => "Exoscale", + DnsServerType::FreeMyIp => "FreeMyIp", + DnsServerType::GandiV5 => "GandiV5", + DnsServerType::Gcore => "Gcore", + DnsServerType::Glesys => "Glesys", + DnsServerType::Godaddy => "Godaddy", + DnsServerType::Hetzner => "Hetzner", + DnsServerType::HostingDe => "HostingDe", + DnsServerType::Hostinger => "Hostinger", + DnsServerType::HuaweiCloud => "HuaweiCloud", + DnsServerType::Hurricane => "Hurricane", + DnsServerType::IbmCloud => "IbmCloud", + DnsServerType::Infoblox => "Infoblox", + DnsServerType::Infomaniak => "Infomaniak", + DnsServerType::Inwx => "Inwx", + DnsServerType::Ionos => "Ionos", + DnsServerType::Ipv64 => "Ipv64", + DnsServerType::Joker => "Joker", + DnsServerType::Lightsail => "Lightsail", + DnsServerType::Linode => "Linode", + DnsServerType::LuaDns => "LuaDns", + DnsServerType::MythicBeasts => "MythicBeasts", + DnsServerType::Namecheap => "Namecheap", + DnsServerType::NameDotCom => "NameDotCom", + DnsServerType::NameSilo => "NameSilo", + DnsServerType::Netcup => "Netcup", + DnsServerType::Netlify => "Netlify", + DnsServerType::Nifcloud => "Nifcloud", + DnsServerType::Ns1 => "Ns1", + DnsServerType::OracleCloud => "OracleCloud", + DnsServerType::Plesk => "Plesk", + DnsServerType::Safedns => "Safedns", + DnsServerType::Scaleway => "Scaleway", + DnsServerType::TencentCloud => "TencentCloud", + DnsServerType::Transip => "Transip", + DnsServerType::UltraDns => "UltraDns", + DnsServerType::Vercel => "Vercel", + DnsServerType::Volcengine => "Volcengine", + DnsServerType::Vultr => "Vultr", + DnsServerType::WebSupport => "WebSupport", + DnsServerType::YandexCloud => "YandexCloud", } } @@ -2900,7 +3247,7 @@ impl EnumImpl for DnsServerType { fn from_id(id: u16) -> Option { match id { 0 => Some(DnsServerType::Tsig), - 1 => Some(DnsServerType::Sig0), + 1 => Some(DnsServerType::Deprecated1), 2 => Some(DnsServerType::Cloudflare), 3 => Some(DnsServerType::DigitalOcean), 4 => Some(DnsServerType::DeSEC), @@ -2911,11 +3258,69 @@ impl EnumImpl for DnsServerType { 9 => Some(DnsServerType::Spaceship), 10 => Some(DnsServerType::Route53), 11 => Some(DnsServerType::GoogleCloudDns), + 12 => Some(DnsServerType::Alidns), + 13 => Some(DnsServerType::ArvanCloud), + 14 => Some(DnsServerType::Autodns), + 15 => Some(DnsServerType::AzureDns), + 16 => Some(DnsServerType::BaiduCloud), + 17 => Some(DnsServerType::BluecatV2), + 18 => Some(DnsServerType::ClouDns), + 19 => Some(DnsServerType::Constellix), + 20 => Some(DnsServerType::Cpanel), + 21 => Some(DnsServerType::Ddnss), + 22 => Some(DnsServerType::DnsMadeEasy), + 23 => Some(DnsServerType::Domeneshop), + 24 => Some(DnsServerType::Dreamhost), + 25 => Some(DnsServerType::DuckDns), + 26 => Some(DnsServerType::Dynu), + 27 => Some(DnsServerType::EasyDns), + 28 => Some(DnsServerType::EdgeDns), + 29 => Some(DnsServerType::Exoscale), + 30 => Some(DnsServerType::FreeMyIp), + 31 => Some(DnsServerType::GandiV5), + 32 => Some(DnsServerType::Gcore), + 33 => Some(DnsServerType::Glesys), + 34 => Some(DnsServerType::Godaddy), + 35 => Some(DnsServerType::Hetzner), + 36 => Some(DnsServerType::HostingDe), + 37 => Some(DnsServerType::Hostinger), + 38 => Some(DnsServerType::HuaweiCloud), + 39 => Some(DnsServerType::Hurricane), + 40 => Some(DnsServerType::IbmCloud), + 41 => Some(DnsServerType::Infoblox), + 42 => Some(DnsServerType::Infomaniak), + 43 => Some(DnsServerType::Inwx), + 44 => Some(DnsServerType::Ionos), + 45 => Some(DnsServerType::Ipv64), + 46 => Some(DnsServerType::Joker), + 47 => Some(DnsServerType::Lightsail), + 48 => Some(DnsServerType::Linode), + 49 => Some(DnsServerType::LuaDns), + 50 => Some(DnsServerType::MythicBeasts), + 51 => Some(DnsServerType::Namecheap), + 52 => Some(DnsServerType::NameDotCom), + 53 => Some(DnsServerType::NameSilo), + 54 => Some(DnsServerType::Netcup), + 55 => Some(DnsServerType::Netlify), + 56 => Some(DnsServerType::Nifcloud), + 57 => Some(DnsServerType::Ns1), + 58 => Some(DnsServerType::OracleCloud), + 59 => Some(DnsServerType::Plesk), + 60 => Some(DnsServerType::Safedns), + 61 => Some(DnsServerType::Scaleway), + 62 => Some(DnsServerType::TencentCloud), + 63 => Some(DnsServerType::Transip), + 64 => Some(DnsServerType::UltraDns), + 65 => Some(DnsServerType::Vercel), + 66 => Some(DnsServerType::Volcengine), + 67 => Some(DnsServerType::Vultr), + 68 => Some(DnsServerType::WebSupport), + 69 => Some(DnsServerType::YandexCloud), _ => None, } } - const COUNT: usize = 12; + const COUNT: usize = 70; } impl serde::Serialize for DnsServerType { @@ -3831,6 +4236,56 @@ impl<'de> serde::Deserialize<'de> for IpProtocol { } } +impl EnumImpl for JokerAuthType { + fn parse(value: &str) -> Option { + hashify::tiny_map! { + value.as_bytes(), + b"ApiKey" => JokerAuthType::ApiKey, + b"UsernamePassword" => JokerAuthType::UsernamePassword, + } + } + + fn as_str(&self) -> &'static str { + match self { + JokerAuthType::ApiKey => "ApiKey", + JokerAuthType::UsernamePassword => "UsernamePassword", + } + } + + fn to_id(&self) -> u16 { + *self as u16 + } + + fn from_id(id: u16) -> Option { + match id { + 0 => Some(JokerAuthType::ApiKey), + 1 => Some(JokerAuthType::UsernamePassword), + _ => None, + } + } + + const COUNT: usize = 2; +} + +impl serde::Serialize for JokerAuthType { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer, + { + serializer.serialize_str(self.as_str()) + } +} + +impl<'de> serde::Deserialize<'de> for JokerAuthType { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let s = Cow::::deserialize(deserializer)?; + Self::parse(&s).ok_or_else(|| serde::de::Error::unknown_variant(&s, &[])) + } +} + impl EnumImpl for JwtSignatureAlgorithm { fn parse(value: &str) -> Option { hashify::tiny_map! { diff --git a/crates/registry/src/schema/properties.rs b/crates/registry/src/schema/properties.rs index 9f2ac709..19abd781 100644 --- a/crates/registry/src/schema/properties.rs +++ b/crates/registry/src/schema/properties.rs @@ -259,6 +259,7 @@ pub enum Property { AbuseBanRate = 677, AccessKey = 118, AccessKeyId = 327, + AccessToken = 890, AccessTokenExpiry = 619, AccessTokens = 132, AccountDomainId = 810, @@ -266,6 +267,7 @@ pub enum Property { AccountIdentifier = 315, AccountKey = 15, AccountName = 809, + AccountSwitchKey = 891, AccountType = 811, AccountUri = 16, Accounts = 151, @@ -305,6 +307,7 @@ pub enum Property { AnonymousClientRegistration = 614, Ansi = 858, ApiKey = 325, + ApiUser = 892, ApplicationKey = 321, ApplicationSecret = 322, ArcResult = 292, @@ -326,11 +329,13 @@ pub enum Property { AttrSecret = 475, AttrSecretChanged = 476, Auid = 215, + Auth = 897, AuthBanPeriod = 680, AuthBanRate = 679, AuthCodeExpiry = 616, AuthCodeMaxAttempts = 613, AuthFailure = 81, + AuthId = 886, AuthSecret = 501, AuthToken = 314, AuthUsername = 502, @@ -339,6 +344,7 @@ pub enum Property { AutoAddInvitations = 171, AutoUpdateFrequency = 53, BaseDn = 463, + BaseUrl = 882, BearerToken = 403, Beta = 389, Bind = 589, @@ -371,17 +377,22 @@ pub enum Property { ClaimUsername = 609, Cleartext = 693, ClientId = 604, + ClientIp = 898, + ClientSecret = 878, + ClientToken = 889, ClusterFile = 382, ColumnClass = 781, ColumnDescription = 782, ColumnEmail = 779, ColumnSecret = 780, Comment = 240, + CompartmentOcid = 905, CompressionAlgorithm = 359, Concurrency = 304, Condition = 34, Confidence = 760, Config = 873, + ConfigName = 883, ConnectTimeout = 505, Connection = 539, ConsumerKey = 323, @@ -392,6 +403,7 @@ pub enum Property { Content = 65, ContentTypes = 758, Contents = 708, + Context = 877, Count = 258, Create = 367, CreatedAt = 46, @@ -402,6 +414,7 @@ pub enum Property { CustomEndpoint = 662, CustomRegion = 663, CustomRule = 787, + CustomerNumber = 899, Dane = 569, DataCleanupSchedule = 199, DataStore = 125, @@ -479,6 +492,7 @@ pub enum Property { DnsServerId = 300, DnsTlsa = 140, DnsTxt = 141, + DnsView = 894, DnsZoneFile = 345, DocumentId = 804, DocumentType = 814, @@ -528,6 +542,7 @@ pub enum Property { EnvRcptTo = 744, EnvelopeFrom = 264, EnvelopeTo = 263, + Environment = 881, ErrorCommand = 210, ErrorMessage = 209, ErrorType = 208, @@ -585,9 +600,11 @@ pub enum Property { FilterLogin = 467, FilterMailbox = 468, FilterMemberOf = 469, + Fingerprint = 902, Flags = 638, FlagsAction = 537, FlagsProtocol = 538, + FolderId = 909, ForDomain = 485, Format = 415, From = 62, @@ -682,6 +699,7 @@ pub enum Property { LearnSpamFromTraps = 729, Level = 373, LicenseKey = 370, + Line = 875, ListenerIds = 183, Listeners = 188, LivePropertyMaxSize = 869, @@ -840,6 +858,7 @@ pub enum Property { ParseLimitContact = 433, ParseLimitEmail = 434, ParseLimitEvent = 432, + Password = 876, PasswordDefaultExpiry = 113, PasswordHashAlgorithm = 109, PasswordMaxLength = 111, @@ -878,6 +897,8 @@ pub enum Property { PreserveIntermediates = 306, Priority = 483, PrivateKey = 177, + PrivateKeyPassword = 904, + PrivateKeyPem = 903, PrivateZone = 319, PrivateZoneOnly = 332, Profile = 661, @@ -948,6 +969,7 @@ pub enum Property { RequireScopes = 608, RequireTls = 525, ReservoirCapacity = 733, + ResourceGroup = 880, ResourceUrl = 51, ResponseCode = 212, ResponseEnhanced = 213, @@ -972,6 +994,7 @@ pub enum Property { RotateAfter = 227, Route = 540, Rua = 236, + Sandbox = 896, SasToken = 119, SaslMechanisms = 549, ScanBanPaths = 683, @@ -979,6 +1002,7 @@ pub enum Property { ScanBanRate = 684, Schedule = 541, Scheduling = 143, + Scheme = 908, Scope = 281, Score = 745, ScoreDiscard = 771, @@ -989,6 +1013,7 @@ pub enum Property { Secret = 3, SecretAccessKey = 328, SecretApiKey = 326, + SecretId = 906, SecretKey = 659, SecurityToken = 660, Selector = 222, @@ -1003,11 +1028,13 @@ pub enum Property { SessionToken = 329, SetMaxObjects = 440, ShardIndex = 830, + SharedSecret = 895, Sig0Algorithm = 336, SignatureAlgorithm = 623, SignatureKey = 624, SignerName = 335, Size = 64, + SkipDeploy = 885, SkipFirst = 423, SmtpGreeting = 552, SnippetMaxResults = 441, @@ -1041,9 +1068,11 @@ pub enum Property { Stores = 694, Strategy = 816, SubAddressing = 347, + SubAuthId = 887, Subject = 41, SubjectAlternativeNames = 178, Subscribe = 368, + SubscriptionId = 879, Sum = 494, Summary = 808, SupportedLanguages = 666, @@ -1052,9 +1081,11 @@ pub enum Property { TaskTypes = 189, Tasks = 187, TcpOnError = 307, + TeamId = 907, TempFailOnError = 528, Temperature = 27, Template = 167, + TenancyOcid = 900, TenantId = 831, Tenants = 153, Text = 2, @@ -1086,6 +1117,7 @@ pub enum Property { TlsImplicit = 602, TlsTimeout = 573, To = 42, + Token = 888, TotalDeadline = 817, TotalFailedSessions = 850, TotalSuccessfulSessions = 849, @@ -1114,6 +1146,7 @@ pub enum Property { UsedDiskQuota = 395, UserAgent = 79, UserCodeExpiry = 620, + UserOcid = 901, Username = 131, UsernameDomain = 610, ValidateDomain = 413, @@ -1121,8 +1154,10 @@ pub enum Property { VariableName = 675, VerifyAfterWrite = 874, Version = 80, + ViewName = 884, Vrfy = 526, WaitOnFail = 548, + WapiVersion = 893, WebsocketHeartbeat = 455, WebsocketThrottle = 456, WebsocketTimeout = 457, diff --git a/crates/registry/src/schema/properties_impl.rs b/crates/registry/src/schema/properties_impl.rs index a114fc73..fbde05b3 100644 --- a/crates/registry/src/schema/properties_impl.rs +++ b/crates/registry/src/schema/properties_impl.rs @@ -412,6 +412,7 @@ impl EnumImpl for Property { b"abuseBanRate" => Property::AbuseBanRate, b"accessKey" => Property::AccessKey, b"accessKeyId" => Property::AccessKeyId, + b"accessToken" => Property::AccessToken, b"accessTokenExpiry" => Property::AccessTokenExpiry, b"accessTokens" => Property::AccessTokens, b"accountDomainId" => Property::AccountDomainId, @@ -419,6 +420,7 @@ impl EnumImpl for Property { b"accountIdentifier" => Property::AccountIdentifier, b"accountKey" => Property::AccountKey, b"accountName" => Property::AccountName, + b"accountSwitchKey" => Property::AccountSwitchKey, b"accountType" => Property::AccountType, b"accountUri" => Property::AccountUri, b"accounts" => Property::Accounts, @@ -458,6 +460,7 @@ impl EnumImpl for Property { b"anonymousClientRegistration" => Property::AnonymousClientRegistration, b"ansi" => Property::Ansi, b"apiKey" => Property::ApiKey, + b"apiUser" => Property::ApiUser, b"applicationKey" => Property::ApplicationKey, b"applicationSecret" => Property::ApplicationSecret, b"arcResult" => Property::ArcResult, @@ -479,11 +482,13 @@ impl EnumImpl for Property { b"attrSecret" => Property::AttrSecret, b"attrSecretChanged" => Property::AttrSecretChanged, b"auid" => Property::Auid, + b"auth" => Property::Auth, b"authBanPeriod" => Property::AuthBanPeriod, b"authBanRate" => Property::AuthBanRate, b"authCodeExpiry" => Property::AuthCodeExpiry, b"authCodeMaxAttempts" => Property::AuthCodeMaxAttempts, b"authFailure" => Property::AuthFailure, + b"authId" => Property::AuthId, b"authSecret" => Property::AuthSecret, b"authToken" => Property::AuthToken, b"authUsername" => Property::AuthUsername, @@ -492,6 +497,7 @@ impl EnumImpl for Property { b"autoAddInvitations" => Property::AutoAddInvitations, b"autoUpdateFrequency" => Property::AutoUpdateFrequency, b"baseDn" => Property::BaseDn, + b"baseUrl" => Property::BaseUrl, b"bearerToken" => Property::BearerToken, b"beta" => Property::Beta, b"bind" => Property::Bind, @@ -524,17 +530,22 @@ impl EnumImpl for Property { b"claimUsername" => Property::ClaimUsername, b"cleartext" => Property::Cleartext, b"clientId" => Property::ClientId, + b"clientIp" => Property::ClientIp, + b"clientSecret" => Property::ClientSecret, + b"clientToken" => Property::ClientToken, b"clusterFile" => Property::ClusterFile, b"columnClass" => Property::ColumnClass, b"columnDescription" => Property::ColumnDescription, b"columnEmail" => Property::ColumnEmail, b"columnSecret" => Property::ColumnSecret, b"comment" => Property::Comment, + b"compartmentOcid" => Property::CompartmentOcid, b"compressionAlgorithm" => Property::CompressionAlgorithm, b"concurrency" => Property::Concurrency, b"condition" => Property::Condition, b"confidence" => Property::Confidence, b"config" => Property::Config, + b"configName" => Property::ConfigName, b"connectTimeout" => Property::ConnectTimeout, b"connection" => Property::Connection, b"consumerKey" => Property::ConsumerKey, @@ -545,6 +556,7 @@ impl EnumImpl for Property { b"content" => Property::Content, b"contentTypes" => Property::ContentTypes, b"contents" => Property::Contents, + b"context" => Property::Context, b"count" => Property::Count, b"create" => Property::Create, b"createdAt" => Property::CreatedAt, @@ -555,6 +567,7 @@ impl EnumImpl for Property { b"customEndpoint" => Property::CustomEndpoint, b"customRegion" => Property::CustomRegion, b"customRule" => Property::CustomRule, + b"customerNumber" => Property::CustomerNumber, b"dane" => Property::Dane, b"dataCleanupSchedule" => Property::DataCleanupSchedule, b"dataStore" => Property::DataStore, @@ -632,6 +645,7 @@ impl EnumImpl for Property { b"dnsServerId" => Property::DnsServerId, b"dnsTlsa" => Property::DnsTlsa, b"dnsTxt" => Property::DnsTxt, + b"dnsView" => Property::DnsView, b"dnsZoneFile" => Property::DnsZoneFile, b"documentId" => Property::DocumentId, b"documentType" => Property::DocumentType, @@ -681,6 +695,7 @@ impl EnumImpl for Property { b"envRcptTo" => Property::EnvRcptTo, b"envelopeFrom" => Property::EnvelopeFrom, b"envelopeTo" => Property::EnvelopeTo, + b"environment" => Property::Environment, b"errorCommand" => Property::ErrorCommand, b"errorMessage" => Property::ErrorMessage, b"errorType" => Property::ErrorType, @@ -738,9 +753,11 @@ impl EnumImpl for Property { b"filterLogin" => Property::FilterLogin, b"filterMailbox" => Property::FilterMailbox, b"filterMemberOf" => Property::FilterMemberOf, + b"fingerprint" => Property::Fingerprint, b"flags" => Property::Flags, b"flagsAction" => Property::FlagsAction, b"flagsProtocol" => Property::FlagsProtocol, + b"folderId" => Property::FolderId, b"forDomain" => Property::ForDomain, b"format" => Property::Format, b"from" => Property::From, @@ -835,6 +852,7 @@ impl EnumImpl for Property { b"learnSpamFromTraps" => Property::LearnSpamFromTraps, b"level" => Property::Level, b"licenseKey" => Property::LicenseKey, + b"line" => Property::Line, b"listenerIds" => Property::ListenerIds, b"listeners" => Property::Listeners, b"livePropertyMaxSize" => Property::LivePropertyMaxSize, @@ -993,6 +1011,7 @@ impl EnumImpl for Property { b"parseLimitContact" => Property::ParseLimitContact, b"parseLimitEmail" => Property::ParseLimitEmail, b"parseLimitEvent" => Property::ParseLimitEvent, + b"password" => Property::Password, b"passwordDefaultExpiry" => Property::PasswordDefaultExpiry, b"passwordHashAlgorithm" => Property::PasswordHashAlgorithm, b"passwordMaxLength" => Property::PasswordMaxLength, @@ -1031,6 +1050,8 @@ impl EnumImpl for Property { b"preserveIntermediates" => Property::PreserveIntermediates, b"priority" => Property::Priority, b"privateKey" => Property::PrivateKey, + b"privateKeyPassword" => Property::PrivateKeyPassword, + b"privateKeyPem" => Property::PrivateKeyPem, b"privateZone" => Property::PrivateZone, b"privateZoneOnly" => Property::PrivateZoneOnly, b"profile" => Property::Profile, @@ -1101,6 +1122,7 @@ impl EnumImpl for Property { b"requireScopes" => Property::RequireScopes, b"requireTls" => Property::RequireTls, b"reservoirCapacity" => Property::ReservoirCapacity, + b"resourceGroup" => Property::ResourceGroup, b"resourceUrl" => Property::ResourceUrl, b"responseCode" => Property::ResponseCode, b"responseEnhanced" => Property::ResponseEnhanced, @@ -1125,6 +1147,7 @@ impl EnumImpl for Property { b"rotateAfter" => Property::RotateAfter, b"route" => Property::Route, b"rua" => Property::Rua, + b"sandbox" => Property::Sandbox, b"sasToken" => Property::SasToken, b"saslMechanisms" => Property::SaslMechanisms, b"scanBanPaths" => Property::ScanBanPaths, @@ -1132,6 +1155,7 @@ impl EnumImpl for Property { b"scanBanRate" => Property::ScanBanRate, b"schedule" => Property::Schedule, b"scheduling" => Property::Scheduling, + b"scheme" => Property::Scheme, b"scope" => Property::Scope, b"score" => Property::Score, b"scoreDiscard" => Property::ScoreDiscard, @@ -1142,6 +1166,7 @@ impl EnumImpl for Property { b"secret" => Property::Secret, b"secretAccessKey" => Property::SecretAccessKey, b"secretApiKey" => Property::SecretApiKey, + b"secretId" => Property::SecretId, b"secretKey" => Property::SecretKey, b"securityToken" => Property::SecurityToken, b"selector" => Property::Selector, @@ -1156,11 +1181,13 @@ impl EnumImpl for Property { b"sessionToken" => Property::SessionToken, b"setMaxObjects" => Property::SetMaxObjects, b"shardIndex" => Property::ShardIndex, + b"sharedSecret" => Property::SharedSecret, b"sig0Algorithm" => Property::Sig0Algorithm, b"signatureAlgorithm" => Property::SignatureAlgorithm, b"signatureKey" => Property::SignatureKey, b"signerName" => Property::SignerName, b"size" => Property::Size, + b"skipDeploy" => Property::SkipDeploy, b"skipFirst" => Property::SkipFirst, b"smtpGreeting" => Property::SmtpGreeting, b"snippetMaxResults" => Property::SnippetMaxResults, @@ -1194,9 +1221,11 @@ impl EnumImpl for Property { b"stores" => Property::Stores, b"strategy" => Property::Strategy, b"subAddressing" => Property::SubAddressing, + b"subAuthId" => Property::SubAuthId, b"subject" => Property::Subject, b"subjectAlternativeNames" => Property::SubjectAlternativeNames, b"subscribe" => Property::Subscribe, + b"subscriptionId" => Property::SubscriptionId, b"sum" => Property::Sum, b"summary" => Property::Summary, b"supportedLanguages" => Property::SupportedLanguages, @@ -1205,9 +1234,11 @@ impl EnumImpl for Property { b"taskTypes" => Property::TaskTypes, b"tasks" => Property::Tasks, b"tcpOnError" => Property::TcpOnError, + b"teamId" => Property::TeamId, b"tempFailOnError" => Property::TempFailOnError, b"temperature" => Property::Temperature, b"template" => Property::Template, + b"tenancyOcid" => Property::TenancyOcid, b"tenantId" => Property::TenantId, b"tenants" => Property::Tenants, b"text" => Property::Text, @@ -1239,6 +1270,7 @@ impl EnumImpl for Property { b"tlsImplicit" => Property::TlsImplicit, b"tlsTimeout" => Property::TlsTimeout, b"to" => Property::To, + b"token" => Property::Token, b"totalDeadline" => Property::TotalDeadline, b"totalFailedSessions" => Property::TotalFailedSessions, b"totalSuccessfulSessions" => Property::TotalSuccessfulSessions, @@ -1267,6 +1299,7 @@ impl EnumImpl for Property { b"usedDiskQuota" => Property::UsedDiskQuota, b"userAgent" => Property::UserAgent, b"userCodeExpiry" => Property::UserCodeExpiry, + b"userOcid" => Property::UserOcid, b"username" => Property::Username, b"usernameDomain" => Property::UsernameDomain, b"validateDomain" => Property::ValidateDomain, @@ -1274,8 +1307,10 @@ impl EnumImpl for Property { b"variableName" => Property::VariableName, b"verifyAfterWrite" => Property::VerifyAfterWrite, b"version" => Property::Version, + b"viewName" => Property::ViewName, b"vrfy" => Property::Vrfy, b"waitOnFail" => Property::WaitOnFail, + b"wapiVersion" => Property::WapiVersion, b"websocketHeartbeat" => Property::WebsocketHeartbeat, b"websocketThrottle" => Property::WebsocketThrottle, b"websocketTimeout" => Property::WebsocketTimeout, @@ -1292,6 +1327,7 @@ impl EnumImpl for Property { Property::AbuseBanRate => "abuseBanRate", Property::AccessKey => "accessKey", Property::AccessKeyId => "accessKeyId", + Property::AccessToken => "accessToken", Property::AccessTokenExpiry => "accessTokenExpiry", Property::AccessTokens => "accessTokens", Property::AccountDomainId => "accountDomainId", @@ -1299,6 +1335,7 @@ impl EnumImpl for Property { Property::AccountIdentifier => "accountIdentifier", Property::AccountKey => "accountKey", Property::AccountName => "accountName", + Property::AccountSwitchKey => "accountSwitchKey", Property::AccountType => "accountType", Property::AccountUri => "accountUri", Property::Accounts => "accounts", @@ -1338,6 +1375,7 @@ impl EnumImpl for Property { Property::AnonymousClientRegistration => "anonymousClientRegistration", Property::Ansi => "ansi", Property::ApiKey => "apiKey", + Property::ApiUser => "apiUser", Property::ApplicationKey => "applicationKey", Property::ApplicationSecret => "applicationSecret", Property::ArcResult => "arcResult", @@ -1359,11 +1397,13 @@ impl EnumImpl for Property { Property::AttrSecret => "attrSecret", Property::AttrSecretChanged => "attrSecretChanged", Property::Auid => "auid", + Property::Auth => "auth", Property::AuthBanPeriod => "authBanPeriod", Property::AuthBanRate => "authBanRate", Property::AuthCodeExpiry => "authCodeExpiry", Property::AuthCodeMaxAttempts => "authCodeMaxAttempts", Property::AuthFailure => "authFailure", + Property::AuthId => "authId", Property::AuthSecret => "authSecret", Property::AuthToken => "authToken", Property::AuthUsername => "authUsername", @@ -1372,6 +1412,7 @@ impl EnumImpl for Property { Property::AutoAddInvitations => "autoAddInvitations", Property::AutoUpdateFrequency => "autoUpdateFrequency", Property::BaseDn => "baseDn", + Property::BaseUrl => "baseUrl", Property::BearerToken => "bearerToken", Property::Beta => "beta", Property::Bind => "bind", @@ -1404,17 +1445,22 @@ impl EnumImpl for Property { Property::ClaimUsername => "claimUsername", Property::Cleartext => "cleartext", Property::ClientId => "clientId", + Property::ClientIp => "clientIp", + Property::ClientSecret => "clientSecret", + Property::ClientToken => "clientToken", Property::ClusterFile => "clusterFile", Property::ColumnClass => "columnClass", Property::ColumnDescription => "columnDescription", Property::ColumnEmail => "columnEmail", Property::ColumnSecret => "columnSecret", Property::Comment => "comment", + Property::CompartmentOcid => "compartmentOcid", Property::CompressionAlgorithm => "compressionAlgorithm", Property::Concurrency => "concurrency", Property::Condition => "condition", Property::Confidence => "confidence", Property::Config => "config", + Property::ConfigName => "configName", Property::ConnectTimeout => "connectTimeout", Property::Connection => "connection", Property::ConsumerKey => "consumerKey", @@ -1425,6 +1471,7 @@ impl EnumImpl for Property { Property::Content => "content", Property::ContentTypes => "contentTypes", Property::Contents => "contents", + Property::Context => "context", Property::Count => "count", Property::Create => "create", Property::CreatedAt => "createdAt", @@ -1435,6 +1482,7 @@ impl EnumImpl for Property { Property::CustomEndpoint => "customEndpoint", Property::CustomRegion => "customRegion", Property::CustomRule => "customRule", + Property::CustomerNumber => "customerNumber", Property::Dane => "dane", Property::DataCleanupSchedule => "dataCleanupSchedule", Property::DataStore => "dataStore", @@ -1512,6 +1560,7 @@ impl EnumImpl for Property { Property::DnsServerId => "dnsServerId", Property::DnsTlsa => "dnsTlsa", Property::DnsTxt => "dnsTxt", + Property::DnsView => "dnsView", Property::DnsZoneFile => "dnsZoneFile", Property::DocumentId => "documentId", Property::DocumentType => "documentType", @@ -1561,6 +1610,7 @@ impl EnumImpl for Property { Property::EnvRcptTo => "envRcptTo", Property::EnvelopeFrom => "envelopeFrom", Property::EnvelopeTo => "envelopeTo", + Property::Environment => "environment", Property::ErrorCommand => "errorCommand", Property::ErrorMessage => "errorMessage", Property::ErrorType => "errorType", @@ -1618,9 +1668,11 @@ impl EnumImpl for Property { Property::FilterLogin => "filterLogin", Property::FilterMailbox => "filterMailbox", Property::FilterMemberOf => "filterMemberOf", + Property::Fingerprint => "fingerprint", Property::Flags => "flags", Property::FlagsAction => "flagsAction", Property::FlagsProtocol => "flagsProtocol", + Property::FolderId => "folderId", Property::ForDomain => "forDomain", Property::Format => "format", Property::From => "from", @@ -1715,6 +1767,7 @@ impl EnumImpl for Property { Property::LearnSpamFromTraps => "learnSpamFromTraps", Property::Level => "level", Property::LicenseKey => "licenseKey", + Property::Line => "line", Property::ListenerIds => "listenerIds", Property::Listeners => "listeners", Property::LivePropertyMaxSize => "livePropertyMaxSize", @@ -1873,6 +1926,7 @@ impl EnumImpl for Property { Property::ParseLimitContact => "parseLimitContact", Property::ParseLimitEmail => "parseLimitEmail", Property::ParseLimitEvent => "parseLimitEvent", + Property::Password => "password", Property::PasswordDefaultExpiry => "passwordDefaultExpiry", Property::PasswordHashAlgorithm => "passwordHashAlgorithm", Property::PasswordMaxLength => "passwordMaxLength", @@ -1911,6 +1965,8 @@ impl EnumImpl for Property { Property::PreserveIntermediates => "preserveIntermediates", Property::Priority => "priority", Property::PrivateKey => "privateKey", + Property::PrivateKeyPassword => "privateKeyPassword", + Property::PrivateKeyPem => "privateKeyPem", Property::PrivateZone => "privateZone", Property::PrivateZoneOnly => "privateZoneOnly", Property::Profile => "profile", @@ -1981,6 +2037,7 @@ impl EnumImpl for Property { Property::RequireScopes => "requireScopes", Property::RequireTls => "requireTls", Property::ReservoirCapacity => "reservoirCapacity", + Property::ResourceGroup => "resourceGroup", Property::ResourceUrl => "resourceUrl", Property::ResponseCode => "responseCode", Property::ResponseEnhanced => "responseEnhanced", @@ -2005,6 +2062,7 @@ impl EnumImpl for Property { Property::RotateAfter => "rotateAfter", Property::Route => "route", Property::Rua => "rua", + Property::Sandbox => "sandbox", Property::SasToken => "sasToken", Property::SaslMechanisms => "saslMechanisms", Property::ScanBanPaths => "scanBanPaths", @@ -2012,6 +2070,7 @@ impl EnumImpl for Property { Property::ScanBanRate => "scanBanRate", Property::Schedule => "schedule", Property::Scheduling => "scheduling", + Property::Scheme => "scheme", Property::Scope => "scope", Property::Score => "score", Property::ScoreDiscard => "scoreDiscard", @@ -2022,6 +2081,7 @@ impl EnumImpl for Property { Property::Secret => "secret", Property::SecretAccessKey => "secretAccessKey", Property::SecretApiKey => "secretApiKey", + Property::SecretId => "secretId", Property::SecretKey => "secretKey", Property::SecurityToken => "securityToken", Property::Selector => "selector", @@ -2036,11 +2096,13 @@ impl EnumImpl for Property { Property::SessionToken => "sessionToken", Property::SetMaxObjects => "setMaxObjects", Property::ShardIndex => "shardIndex", + Property::SharedSecret => "sharedSecret", Property::Sig0Algorithm => "sig0Algorithm", Property::SignatureAlgorithm => "signatureAlgorithm", Property::SignatureKey => "signatureKey", Property::SignerName => "signerName", Property::Size => "size", + Property::SkipDeploy => "skipDeploy", Property::SkipFirst => "skipFirst", Property::SmtpGreeting => "smtpGreeting", Property::SnippetMaxResults => "snippetMaxResults", @@ -2074,9 +2136,11 @@ impl EnumImpl for Property { Property::Stores => "stores", Property::Strategy => "strategy", Property::SubAddressing => "subAddressing", + Property::SubAuthId => "subAuthId", Property::Subject => "subject", Property::SubjectAlternativeNames => "subjectAlternativeNames", Property::Subscribe => "subscribe", + Property::SubscriptionId => "subscriptionId", Property::Sum => "sum", Property::Summary => "summary", Property::SupportedLanguages => "supportedLanguages", @@ -2085,9 +2149,11 @@ impl EnumImpl for Property { Property::TaskTypes => "taskTypes", Property::Tasks => "tasks", Property::TcpOnError => "tcpOnError", + Property::TeamId => "teamId", Property::TempFailOnError => "tempFailOnError", Property::Temperature => "temperature", Property::Template => "template", + Property::TenancyOcid => "tenancyOcid", Property::TenantId => "tenantId", Property::Tenants => "tenants", Property::Text => "text", @@ -2119,6 +2185,7 @@ impl EnumImpl for Property { Property::TlsImplicit => "tlsImplicit", Property::TlsTimeout => "tlsTimeout", Property::To => "to", + Property::Token => "token", Property::TotalDeadline => "totalDeadline", Property::TotalFailedSessions => "totalFailedSessions", Property::TotalSuccessfulSessions => "totalSuccessfulSessions", @@ -2147,6 +2214,7 @@ impl EnumImpl for Property { Property::UsedDiskQuota => "usedDiskQuota", Property::UserAgent => "userAgent", Property::UserCodeExpiry => "userCodeExpiry", + Property::UserOcid => "userOcid", Property::Username => "username", Property::UsernameDomain => "usernameDomain", Property::ValidateDomain => "validateDomain", @@ -2154,8 +2222,10 @@ impl EnumImpl for Property { Property::VariableName => "variableName", Property::VerifyAfterWrite => "verifyAfterWrite", Property::Version => "version", + Property::ViewName => "viewName", Property::Vrfy => "vrfy", Property::WaitOnFail => "waitOnFail", + Property::WapiVersion => "wapiVersion", Property::WebsocketHeartbeat => "websocketHeartbeat", Property::WebsocketThrottle => "websocketThrottle", Property::WebsocketTimeout => "websocketTimeout", @@ -2176,6 +2246,7 @@ impl EnumImpl for Property { 677 => Some(Property::AbuseBanRate), 118 => Some(Property::AccessKey), 327 => Some(Property::AccessKeyId), + 890 => Some(Property::AccessToken), 619 => Some(Property::AccessTokenExpiry), 132 => Some(Property::AccessTokens), 810 => Some(Property::AccountDomainId), @@ -2183,6 +2254,7 @@ impl EnumImpl for Property { 315 => Some(Property::AccountIdentifier), 15 => Some(Property::AccountKey), 809 => Some(Property::AccountName), + 891 => Some(Property::AccountSwitchKey), 811 => Some(Property::AccountType), 16 => Some(Property::AccountUri), 151 => Some(Property::Accounts), @@ -2222,6 +2294,7 @@ impl EnumImpl for Property { 614 => Some(Property::AnonymousClientRegistration), 858 => Some(Property::Ansi), 325 => Some(Property::ApiKey), + 892 => Some(Property::ApiUser), 321 => Some(Property::ApplicationKey), 322 => Some(Property::ApplicationSecret), 292 => Some(Property::ArcResult), @@ -2243,11 +2316,13 @@ impl EnumImpl for Property { 475 => Some(Property::AttrSecret), 476 => Some(Property::AttrSecretChanged), 215 => Some(Property::Auid), + 897 => Some(Property::Auth), 680 => Some(Property::AuthBanPeriod), 679 => Some(Property::AuthBanRate), 616 => Some(Property::AuthCodeExpiry), 613 => Some(Property::AuthCodeMaxAttempts), 81 => Some(Property::AuthFailure), + 886 => Some(Property::AuthId), 501 => Some(Property::AuthSecret), 314 => Some(Property::AuthToken), 502 => Some(Property::AuthUsername), @@ -2256,6 +2331,7 @@ impl EnumImpl for Property { 171 => Some(Property::AutoAddInvitations), 53 => Some(Property::AutoUpdateFrequency), 463 => Some(Property::BaseDn), + 882 => Some(Property::BaseUrl), 403 => Some(Property::BearerToken), 389 => Some(Property::Beta), 589 => Some(Property::Bind), @@ -2288,17 +2364,22 @@ impl EnumImpl for Property { 609 => Some(Property::ClaimUsername), 693 => Some(Property::Cleartext), 604 => Some(Property::ClientId), + 898 => Some(Property::ClientIp), + 878 => Some(Property::ClientSecret), + 889 => Some(Property::ClientToken), 382 => Some(Property::ClusterFile), 781 => Some(Property::ColumnClass), 782 => Some(Property::ColumnDescription), 779 => Some(Property::ColumnEmail), 780 => Some(Property::ColumnSecret), 240 => Some(Property::Comment), + 905 => Some(Property::CompartmentOcid), 359 => Some(Property::CompressionAlgorithm), 304 => Some(Property::Concurrency), 34 => Some(Property::Condition), 760 => Some(Property::Confidence), 873 => Some(Property::Config), + 883 => Some(Property::ConfigName), 505 => Some(Property::ConnectTimeout), 539 => Some(Property::Connection), 323 => Some(Property::ConsumerKey), @@ -2309,6 +2390,7 @@ impl EnumImpl for Property { 65 => Some(Property::Content), 758 => Some(Property::ContentTypes), 708 => Some(Property::Contents), + 877 => Some(Property::Context), 258 => Some(Property::Count), 367 => Some(Property::Create), 46 => Some(Property::CreatedAt), @@ -2319,6 +2401,7 @@ impl EnumImpl for Property { 662 => Some(Property::CustomEndpoint), 663 => Some(Property::CustomRegion), 787 => Some(Property::CustomRule), + 899 => Some(Property::CustomerNumber), 569 => Some(Property::Dane), 199 => Some(Property::DataCleanupSchedule), 125 => Some(Property::DataStore), @@ -2396,6 +2479,7 @@ impl EnumImpl for Property { 300 => Some(Property::DnsServerId), 140 => Some(Property::DnsTlsa), 141 => Some(Property::DnsTxt), + 894 => Some(Property::DnsView), 345 => Some(Property::DnsZoneFile), 804 => Some(Property::DocumentId), 814 => Some(Property::DocumentType), @@ -2445,6 +2529,7 @@ impl EnumImpl for Property { 744 => Some(Property::EnvRcptTo), 264 => Some(Property::EnvelopeFrom), 263 => Some(Property::EnvelopeTo), + 881 => Some(Property::Environment), 210 => Some(Property::ErrorCommand), 209 => Some(Property::ErrorMessage), 208 => Some(Property::ErrorType), @@ -2502,9 +2587,11 @@ impl EnumImpl for Property { 467 => Some(Property::FilterLogin), 468 => Some(Property::FilterMailbox), 469 => Some(Property::FilterMemberOf), + 902 => Some(Property::Fingerprint), 638 => Some(Property::Flags), 537 => Some(Property::FlagsAction), 538 => Some(Property::FlagsProtocol), + 909 => Some(Property::FolderId), 485 => Some(Property::ForDomain), 415 => Some(Property::Format), 62 => Some(Property::From), @@ -2599,6 +2686,7 @@ impl EnumImpl for Property { 729 => Some(Property::LearnSpamFromTraps), 373 => Some(Property::Level), 370 => Some(Property::LicenseKey), + 875 => Some(Property::Line), 183 => Some(Property::ListenerIds), 188 => Some(Property::Listeners), 869 => Some(Property::LivePropertyMaxSize), @@ -2757,6 +2845,7 @@ impl EnumImpl for Property { 433 => Some(Property::ParseLimitContact), 434 => Some(Property::ParseLimitEmail), 432 => Some(Property::ParseLimitEvent), + 876 => Some(Property::Password), 113 => Some(Property::PasswordDefaultExpiry), 109 => Some(Property::PasswordHashAlgorithm), 111 => Some(Property::PasswordMaxLength), @@ -2795,6 +2884,8 @@ impl EnumImpl for Property { 306 => Some(Property::PreserveIntermediates), 483 => Some(Property::Priority), 177 => Some(Property::PrivateKey), + 904 => Some(Property::PrivateKeyPassword), + 903 => Some(Property::PrivateKeyPem), 319 => Some(Property::PrivateZone), 332 => Some(Property::PrivateZoneOnly), 661 => Some(Property::Profile), @@ -2865,6 +2956,7 @@ impl EnumImpl for Property { 608 => Some(Property::RequireScopes), 525 => Some(Property::RequireTls), 733 => Some(Property::ReservoirCapacity), + 880 => Some(Property::ResourceGroup), 51 => Some(Property::ResourceUrl), 212 => Some(Property::ResponseCode), 213 => Some(Property::ResponseEnhanced), @@ -2889,6 +2981,7 @@ impl EnumImpl for Property { 227 => Some(Property::RotateAfter), 540 => Some(Property::Route), 236 => Some(Property::Rua), + 896 => Some(Property::Sandbox), 119 => Some(Property::SasToken), 549 => Some(Property::SaslMechanisms), 683 => Some(Property::ScanBanPaths), @@ -2896,6 +2989,7 @@ impl EnumImpl for Property { 684 => Some(Property::ScanBanRate), 541 => Some(Property::Schedule), 143 => Some(Property::Scheduling), + 908 => Some(Property::Scheme), 281 => Some(Property::Scope), 745 => Some(Property::Score), 771 => Some(Property::ScoreDiscard), @@ -2906,6 +3000,7 @@ impl EnumImpl for Property { 3 => Some(Property::Secret), 328 => Some(Property::SecretAccessKey), 326 => Some(Property::SecretApiKey), + 906 => Some(Property::SecretId), 659 => Some(Property::SecretKey), 660 => Some(Property::SecurityToken), 222 => Some(Property::Selector), @@ -2920,11 +3015,13 @@ impl EnumImpl for Property { 329 => Some(Property::SessionToken), 440 => Some(Property::SetMaxObjects), 830 => Some(Property::ShardIndex), + 895 => Some(Property::SharedSecret), 336 => Some(Property::Sig0Algorithm), 623 => Some(Property::SignatureAlgorithm), 624 => Some(Property::SignatureKey), 335 => Some(Property::SignerName), 64 => Some(Property::Size), + 885 => Some(Property::SkipDeploy), 423 => Some(Property::SkipFirst), 552 => Some(Property::SmtpGreeting), 441 => Some(Property::SnippetMaxResults), @@ -2958,9 +3055,11 @@ impl EnumImpl for Property { 694 => Some(Property::Stores), 816 => Some(Property::Strategy), 347 => Some(Property::SubAddressing), + 887 => Some(Property::SubAuthId), 41 => Some(Property::Subject), 178 => Some(Property::SubjectAlternativeNames), 368 => Some(Property::Subscribe), + 879 => Some(Property::SubscriptionId), 494 => Some(Property::Sum), 808 => Some(Property::Summary), 666 => Some(Property::SupportedLanguages), @@ -2969,9 +3068,11 @@ impl EnumImpl for Property { 189 => Some(Property::TaskTypes), 187 => Some(Property::Tasks), 307 => Some(Property::TcpOnError), + 907 => Some(Property::TeamId), 528 => Some(Property::TempFailOnError), 27 => Some(Property::Temperature), 167 => Some(Property::Template), + 900 => Some(Property::TenancyOcid), 831 => Some(Property::TenantId), 153 => Some(Property::Tenants), 2 => Some(Property::Text), @@ -3003,6 +3104,7 @@ impl EnumImpl for Property { 602 => Some(Property::TlsImplicit), 573 => Some(Property::TlsTimeout), 42 => Some(Property::To), + 888 => Some(Property::Token), 817 => Some(Property::TotalDeadline), 850 => Some(Property::TotalFailedSessions), 849 => Some(Property::TotalSuccessfulSessions), @@ -3031,6 +3133,7 @@ impl EnumImpl for Property { 395 => Some(Property::UsedDiskQuota), 79 => Some(Property::UserAgent), 620 => Some(Property::UserCodeExpiry), + 901 => Some(Property::UserOcid), 131 => Some(Property::Username), 610 => Some(Property::UsernameDomain), 413 => Some(Property::ValidateDomain), @@ -3038,8 +3141,10 @@ impl EnumImpl for Property { 675 => Some(Property::VariableName), 874 => Some(Property::VerifyAfterWrite), 80 => Some(Property::Version), + 884 => Some(Property::ViewName), 526 => Some(Property::Vrfy), 548 => Some(Property::WaitOnFail), + 893 => Some(Property::WapiVersion), 455 => Some(Property::WebsocketHeartbeat), 456 => Some(Property::WebsocketThrottle), 457 => Some(Property::WebsocketTimeout), @@ -3050,7 +3155,7 @@ impl EnumImpl for Property { } } - const COUNT: usize = 875; + const COUNT: usize = 910; } impl serde::Serialize for Property { @@ -4234,7 +4339,6 @@ impl ObjectInner { ObjectInner::DkimSignature(DkimSignature::Dkim1RsaSha256(obj)) => obj.member_tenant_id, ObjectInner::DmarcExternalReport(obj) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::Tsig(obj)) => obj.member_tenant_id, - ObjectInner::DnsServer(DnsServer::Sig0(obj)) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::Cloudflare(obj)) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::DigitalOcean(obj)) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::DeSEC(obj)) => obj.member_tenant_id, @@ -4245,6 +4349,64 @@ impl ObjectInner { ObjectInner::DnsServer(DnsServer::Spaceship(obj)) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::Route53(obj)) => obj.member_tenant_id, ObjectInner::DnsServer(DnsServer::GoogleCloudDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Alidns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::ArvanCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Autodns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::AzureDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::BaiduCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::BluecatV2(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::ClouDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Constellix(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Cpanel(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Ddnss(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::DnsMadeEasy(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Domeneshop(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Dreamhost(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::DuckDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Dynu(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::EasyDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::EdgeDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Exoscale(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::FreeMyIp(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::GandiV5(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Gcore(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Glesys(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Godaddy(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Hetzner(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::HostingDe(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Hostinger(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::HuaweiCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Hurricane(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::IbmCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Infoblox(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Infomaniak(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Inwx(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Ionos(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Ipv64(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Joker(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Lightsail(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Linode(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::LuaDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::MythicBeasts(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Namecheap(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::NameDotCom(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::NameSilo(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Netcup(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Netlify(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Nifcloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Ns1(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::OracleCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Plesk(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Safedns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Scaleway(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::TencentCloud(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Transip(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::UltraDns(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Vercel(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Volcengine(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::Vultr(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::WebSupport(obj)) => obj.member_tenant_id, + ObjectInner::DnsServer(DnsServer::YandexCloud(obj)) => obj.member_tenant_id, ObjectInner::Domain(obj) => obj.member_tenant_id, ObjectInner::MailingList(obj) => obj.member_tenant_id, ObjectInner::OAuthClient(obj) => obj.member_tenant_id, @@ -4271,7 +4433,6 @@ impl ObjectInner { } ObjectInner::DmarcExternalReport(obj) => obj.member_tenant_id = Some(id), ObjectInner::DnsServer(DnsServer::Tsig(obj)) => obj.member_tenant_id = Some(id), - ObjectInner::DnsServer(DnsServer::Sig0(obj)) => obj.member_tenant_id = Some(id), ObjectInner::DnsServer(DnsServer::Cloudflare(obj)) => obj.member_tenant_id = Some(id), ObjectInner::DnsServer(DnsServer::DigitalOcean(obj)) => obj.member_tenant_id = Some(id), ObjectInner::DnsServer(DnsServer::DeSEC(obj)) => obj.member_tenant_id = Some(id), @@ -4284,6 +4445,64 @@ impl ObjectInner { ObjectInner::DnsServer(DnsServer::GoogleCloudDns(obj)) => { obj.member_tenant_id = Some(id) } + ObjectInner::DnsServer(DnsServer::Alidns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::ArvanCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Autodns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::AzureDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::BaiduCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::BluecatV2(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::ClouDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Constellix(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Cpanel(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Ddnss(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::DnsMadeEasy(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Domeneshop(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Dreamhost(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::DuckDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Dynu(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::EasyDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::EdgeDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Exoscale(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::FreeMyIp(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::GandiV5(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Gcore(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Glesys(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Godaddy(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Hetzner(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::HostingDe(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Hostinger(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::HuaweiCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Hurricane(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::IbmCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Infoblox(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Infomaniak(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Inwx(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Ionos(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Ipv64(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Joker(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Lightsail(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Linode(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::LuaDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::MythicBeasts(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Namecheap(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::NameDotCom(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::NameSilo(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Netcup(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Netlify(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Nifcloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Ns1(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::OracleCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Plesk(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Safedns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Scaleway(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::TencentCloud(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Transip(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::UltraDns(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Vercel(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Volcengine(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::Vultr(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::WebSupport(obj)) => obj.member_tenant_id = Some(id), + ObjectInner::DnsServer(DnsServer::YandexCloud(obj)) => obj.member_tenant_id = Some(id), ObjectInner::Domain(obj) => obj.member_tenant_id = Some(id), ObjectInner::MailingList(obj) => obj.member_tenant_id = Some(id), ObjectInner::OAuthClient(obj) => obj.member_tenant_id = Some(id), diff --git a/crates/registry/src/schema/structs.rs b/crates/registry/src/schema/structs.rs index 3b867bfb..92949fe2 100644 --- a/crates/registry/src/schema/structs.rs +++ b/crates/registry/src/schema/structs.rs @@ -1344,7 +1344,7 @@ pub struct DnsResolverTls { #[serde(tag = "@type")] pub enum DnsServer { Tsig(DnsServerTsig), - Sig0(DnsServerSig0), + Deprecated1, Cloudflare(DnsServerCloudflare), DigitalOcean(DnsServerCloud), DeSEC(DnsServerCloud), @@ -1355,6 +1355,203 @@ pub enum DnsServer { Spaceship(DnsServerSpaceship), Route53(DnsServerRoute53), GoogleCloudDns(DnsServerGoogleCloudDns), + Alidns(DnsServerAlidns), + ArvanCloud(DnsServerCloud), + Autodns(DnsServerAutodns), + AzureDns(DnsServerAzureDns), + BaiduCloud(DnsServerBaiduCloud), + BluecatV2(DnsServerBluecatV2), + ClouDns(DnsServerClouDns), + Constellix(DnsServerConstellix), + Cpanel(DnsServerCpanel), + Ddnss(DnsServerCloud), + DnsMadeEasy(DnsServerDnsMadeEasy), + Domeneshop(DnsServerDomeneshop), + Dreamhost(DnsServerCloud), + DuckDns(DnsServerCloud), + Dynu(DnsServerCloud), + EasyDns(DnsServerEasyDns), + EdgeDns(DnsServerEdgeDns), + Exoscale(DnsServerExoscale), + FreeMyIp(DnsServerCloud), + GandiV5(DnsServerCloud), + Gcore(DnsServerCloud), + Glesys(DnsServerGlesys), + Godaddy(DnsServerGodaddy), + Hetzner(DnsServerCloud), + HostingDe(DnsServerCloud), + Hostinger(DnsServerCloud), + HuaweiCloud(DnsServerHuaweiCloud), + Hurricane(DnsServerHurricane), + IbmCloud(DnsServerIbmCloud), + Infoblox(DnsServerInfoblox), + Infomaniak(DnsServerCloud), + Inwx(DnsServerInwx), + Ionos(DnsServerCloud), + Ipv64(DnsServerCloud), + Joker(DnsServerJoker), + Lightsail(DnsServerLightsail), + Linode(DnsServerCloud), + LuaDns(DnsServerLuaDns), + MythicBeasts(DnsServerMythicBeasts), + Namecheap(DnsServerNamecheap), + NameDotCom(DnsServerNameDotCom), + NameSilo(DnsServerCloud), + Netcup(DnsServerNetcup), + Netlify(DnsServerCloud), + Nifcloud(DnsServerNifcloud), + Ns1(DnsServerCloud), + OracleCloud(DnsServerOracleCloud), + Plesk(DnsServerPlesk), + Safedns(DnsServerCloud), + Scaleway(DnsServerCloud), + TencentCloud(DnsServerTencentCloud), + Transip(DnsServerTransip), + UltraDns(DnsServerUltraDns), + Vercel(DnsServerVercel), + Volcengine(DnsServerVolcengine), + Vultr(DnsServerCloud), + WebSupport(DnsServerWebSupport), + YandexCloud(DnsServerYandexCloud), +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerAlidns { + #[serde(rename = "accessKey")] + pub access_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "region")] + pub region: Option, + #[serde(rename = "securityToken")] + pub security_token: SecretKeyOptional, + #[serde(rename = "line")] + pub line: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerAutodns { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "context")] + pub context: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerAzureDns { + #[serde(rename = "tenantId")] + pub tenant_id: String, + #[serde(rename = "clientId")] + pub client_id: String, + #[serde(rename = "clientSecret")] + pub client_secret: SecretKey, + #[serde(rename = "subscriptionId")] + pub subscription_id: String, + #[serde(rename = "resourceGroup")] + pub resource_group: String, + #[serde(rename = "environment")] + pub environment: AzureEnvironment, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerBaiduCloud { + #[serde(rename = "accessKey")] + pub access_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerBluecatV2 { + #[serde(rename = "baseUrl")] + pub base_url: String, + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "configName")] + pub config_name: String, + #[serde(rename = "viewName")] + pub view_name: String, + #[serde(rename = "skipDeploy")] + pub skip_deploy: bool, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -1362,7 +1559,7 @@ pub enum DnsServer { pub enum DnsServerBootstrap { Manual, Tsig(DnsServerTsig), - Sig0(DnsServerSig0), + Deprecated1, Cloudflare(DnsServerCloudflare), DigitalOcean(DnsServerCloud), DeSEC(DnsServerCloud), @@ -1373,6 +1570,89 @@ pub enum DnsServerBootstrap { Spaceship(DnsServerSpaceship), Route53(DnsServerRoute53), GoogleCloudDns(DnsServerGoogleCloudDns), + Alidns(DnsServerAlidns), + ArvanCloud(DnsServerCloud), + Autodns(DnsServerAutodns), + AzureDns(DnsServerAzureDns), + BaiduCloud(DnsServerBaiduCloud), + BluecatV2(DnsServerBluecatV2), + ClouDns(DnsServerClouDns), + Constellix(DnsServerConstellix), + Cpanel(DnsServerCpanel), + Ddnss(DnsServerCloud), + DnsMadeEasy(DnsServerDnsMadeEasy), + Domeneshop(DnsServerDomeneshop), + Dreamhost(DnsServerCloud), + DuckDns(DnsServerCloud), + Dynu(DnsServerCloud), + EasyDns(DnsServerEasyDns), + EdgeDns(DnsServerEdgeDns), + Exoscale(DnsServerExoscale), + FreeMyIp(DnsServerCloud), + GandiV5(DnsServerCloud), + Gcore(DnsServerCloud), + Glesys(DnsServerGlesys), + Godaddy(DnsServerGodaddy), + Hetzner(DnsServerCloud), + HostingDe(DnsServerCloud), + Hostinger(DnsServerCloud), + HuaweiCloud(DnsServerHuaweiCloud), + Hurricane(DnsServerHurricane), + IbmCloud(DnsServerIbmCloud), + Infoblox(DnsServerInfoblox), + Infomaniak(DnsServerCloud), + Inwx(DnsServerInwx), + Ionos(DnsServerCloud), + Ipv64(DnsServerCloud), + Joker(DnsServerJoker), + Lightsail(DnsServerLightsail), + Linode(DnsServerCloud), + LuaDns(DnsServerLuaDns), + MythicBeasts(DnsServerMythicBeasts), + Namecheap(DnsServerNamecheap), + NameDotCom(DnsServerNameDotCom), + NameSilo(DnsServerCloud), + Netcup(DnsServerNetcup), + Netlify(DnsServerCloud), + Nifcloud(DnsServerNifcloud), + Ns1(DnsServerCloud), + OracleCloud(DnsServerOracleCloud), + Plesk(DnsServerPlesk), + Safedns(DnsServerCloud), + Scaleway(DnsServerCloud), + TencentCloud(DnsServerTencentCloud), + Transip(DnsServerTransip), + UltraDns(DnsServerUltraDns), + Vercel(DnsServerVercel), + Volcengine(DnsServerVolcengine), + Vultr(DnsServerCloud), + WebSupport(DnsServerWebSupport), + YandexCloud(DnsServerYandexCloud), +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerClouDns { + #[serde(rename = "authId")] + pub auth_id: Option, + #[serde(rename = "subAuthId")] + pub sub_auth_id: Option, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -1399,8 +1679,77 @@ pub struct DnsServerCloud { #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct DnsServerCloudflare { - #[serde(rename = "email")] - pub email: Option, + #[serde(rename = "secret")] + pub secret: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerConstellix { + #[serde(rename = "apiKey")] + pub api_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerCpanel { + #[serde(rename = "baseUrl")] + pub base_url: String, + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "token")] + pub token: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerDnsMadeEasy { + #[serde(rename = "apiKey")] + pub api_key: String, #[serde(rename = "secret")] pub secret: SecretKey, #[serde(rename = "description")] @@ -1426,6 +1775,148 @@ pub struct DnsServerDnsimple { pub auth_token: SecretKey, #[serde(rename = "accountIdentifier")] pub account_identifier: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerDomeneshop { + #[serde(rename = "authToken")] + pub auth_token: String, + #[serde(rename = "secret")] + pub secret: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerEasyDns { + #[serde(rename = "token")] + pub token: String, + #[serde(rename = "key")] + pub key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerEdgeDns { + #[serde(rename = "host")] + pub host: String, + #[serde(rename = "clientToken")] + pub client_token: String, + #[serde(rename = "clientSecret")] + pub client_secret: SecretKey, + #[serde(rename = "accessToken")] + pub access_token: SecretKey, + #[serde(rename = "accountSwitchKey")] + pub account_switch_key: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerExoscale { + #[serde(rename = "apiKey")] + pub api_key: String, + #[serde(rename = "secret")] + pub secret: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerGlesys { + #[serde(rename = "apiUser")] + pub api_user: String, + #[serde(rename = "apiKey")] + pub api_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerGodaddy { + #[serde(rename = "apiKey")] + pub api_key: String, #[serde(rename = "secret")] pub secret: SecretKey, #[serde(rename = "description")] @@ -1473,6 +1964,360 @@ pub struct DnsServerGoogleCloudDns { pub propagation_delay: Option, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerHuaweiCloud { + #[serde(rename = "accessKey")] + pub access_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "region")] + pub region: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerHurricane { + #[serde(rename = "credentials")] + pub credentials: List, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerIbmCloud { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "apiKey")] + pub api_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerInfoblox { + #[serde(rename = "host")] + pub host: String, + #[serde(rename = "port")] + pub port: Option, + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "wapiVersion")] + pub wapi_version: Option, + #[serde(rename = "dnsView")] + pub dns_view: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerInwx { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "sharedSecret")] + pub shared_secret: SecretKeyOptional, + #[serde(rename = "sandbox")] + pub sandbox: bool, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerJoker { + #[serde(rename = "auth")] + pub auth: JokerAuth, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerLightsail { + #[serde(rename = "accessKeyId")] + pub access_key_id: String, + #[serde(rename = "secretAccessKey")] + pub secret_access_key: SecretKey, + #[serde(rename = "sessionToken")] + pub session_token: SecretKeyOptional, + #[serde(rename = "region")] + pub region: Option, + #[serde(rename = "domain")] + pub domain: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerLuaDns { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "authToken")] + pub auth_token: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerMythicBeasts { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerNameDotCom { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "authToken")] + pub auth_token: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerNamecheap { + #[serde(rename = "apiUser")] + pub api_user: String, + #[serde(rename = "apiKey")] + pub api_key: SecretKey, + #[serde(rename = "clientIp")] + pub client_ip: String, + #[serde(rename = "username")] + pub username: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerNetcup { + #[serde(rename = "customerNumber")] + pub customer_number: String, + #[serde(rename = "apiKey")] + pub api_key: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerNifcloud { + #[serde(rename = "accessKey")] + pub access_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerOracleCloud { + #[serde(rename = "tenancyOcid")] + pub tenancy_ocid: String, + #[serde(rename = "userOcid")] + pub user_ocid: String, + #[serde(rename = "fingerprint")] + pub fingerprint: String, + #[serde(rename = "privateKeyPem")] + pub private_key_pem: SecretText, + #[serde(rename = "privateKeyPassword")] + pub private_key_password: SecretKeyOptional, + #[serde(rename = "region")] + pub region: String, + #[serde(rename = "compartmentOcid")] + pub compartment_ocid: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct DnsServerOvh { @@ -1500,6 +2345,29 @@ pub struct DnsServerOvh { pub propagation_delay: Option, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerPlesk { + #[serde(rename = "baseUrl")] + pub base_url: String, + #[serde(rename = "apiKey")] + pub api_key: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct DnsServerPorkbun { @@ -1507,8 +2375,6 @@ pub struct DnsServerPorkbun { pub api_key: String, #[serde(rename = "secretApiKey")] pub secret_api_key: SecretKey, - #[serde(rename = "secret")] - pub secret: SecretKey, #[serde(rename = "description")] pub description: String, #[serde(rename = "memberTenantId")] @@ -1558,21 +2424,11 @@ pub struct DnsServerRoute53 { #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] -pub struct DnsServerSig0 { - #[serde(rename = "host")] - pub host: IpAddr, - #[serde(rename = "port")] - pub port: u64, - #[serde(rename = "publicKey")] - pub public_key: String, - #[serde(rename = "key")] - pub key: SecretText, - #[serde(rename = "signerName")] - pub signer_name: String, - #[serde(rename = "protocol")] - pub protocol: IpProtocol, - #[serde(rename = "sig0Algorithm")] - pub sig0_algorithm: Sig0Algorithm, +pub struct DnsServerSpaceship { + #[serde(rename = "apiKey")] + pub api_key: String, + #[serde(rename = "secret")] + pub secret: SecretKey, #[serde(rename = "description")] pub description: String, #[serde(rename = "memberTenantId")] @@ -1591,11 +2447,38 @@ pub struct DnsServerSig0 { #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] -pub struct DnsServerSpaceship { - #[serde(rename = "apiKey")] - pub api_key: String, - #[serde(rename = "secret")] - pub secret: SecretKey, +pub struct DnsServerTencentCloud { + #[serde(rename = "secretId")] + pub secret_id: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "region")] + pub region: Option, + #[serde(rename = "sessionToken")] + pub session_token: SecretKeyOptional, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerTransip { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "privateKeyPem")] + pub private_key_pem: SecretText, #[serde(rename = "description")] pub description: String, #[serde(rename = "memberTenantId")] @@ -1643,6 +2526,129 @@ pub struct DnsServerTsig { pub propagation_delay: Option, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerUltraDns { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, + #[serde(rename = "endpoint")] + pub endpoint: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerVercel { + #[serde(rename = "authToken")] + pub auth_token: SecretKey, + #[serde(rename = "teamId")] + pub team_id: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerVolcengine { + #[serde(rename = "accessKey")] + pub access_key: String, + #[serde(rename = "secretKey")] + pub secret_key: SecretKey, + #[serde(rename = "region")] + pub region: Option, + #[serde(rename = "host")] + pub host: Option, + #[serde(rename = "scheme")] + pub scheme: Option, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerWebSupport { + #[serde(rename = "apiKey")] + pub api_key: String, + #[serde(rename = "secret")] + pub secret: SecretKey, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct DnsServerYandexCloud { + #[serde(rename = "apiKey")] + pub api_key: SecretText, + #[serde(rename = "folderId")] + pub folder_id: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "memberTenantId")] + pub member_tenant_id: Option, + #[serde(rename = "timeout")] + pub timeout: Duration, + #[serde(rename = "ttl")] + pub ttl: Duration, + #[serde(rename = "pollingInterval")] + pub polling_interval: Duration, + #[serde(rename = "propagationTimeout")] + pub propagation_timeout: Duration, + #[serde(rename = "propagationDelay")] + pub propagation_delay: Option, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct Domain { @@ -2024,6 +3030,15 @@ pub enum HttpLookupFormat { List, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct HurricaneCredential { + #[serde(rename = "zone")] + pub zone: String, + #[serde(rename = "secret")] + pub secret: SecretKey, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct Imap { @@ -2122,6 +3137,29 @@ pub struct Jmap { pub max_subscriptions: Option, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "@type")] +pub enum JokerAuth { + ApiKey(JokerAuthApiKey), + UsernamePassword(JokerAuthUsernamePassword), +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct JokerAuthApiKey { + #[serde(rename = "apiKey")] + pub api_key: SecretKey, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct JokerAuthUsernamePassword { + #[serde(rename = "username")] + pub username: String, + #[serde(rename = "password")] + pub password: SecretKey, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct KafkaCoordinator { diff --git a/crates/registry/src/schema/structs_impl.rs b/crates/registry/src/schema/structs_impl.rs index 254b0418..7d797331 100644 --- a/crates/registry/src/schema/structs_impl.rs +++ b/crates/registry/src/schema/structs_impl.rs @@ -10195,13 +10195,13 @@ impl RegistryJsonPropertyPatch for DnsResolverTls { impl ObjectImpl for DnsServer { const FLAGS: u64 = OBJ_FILTER_TENANT; - const VERSION: u8 = 0; + const VERSION: u8 = 1; const OBJECT: ObjectType = ObjectType::DnsServer; fn validate(&self, errors: &mut Vec) -> bool { match self { DnsServer::Tsig(inner) => inner.validate(errors), - DnsServer::Sig0(inner) => inner.validate(errors), + DnsServer::Deprecated1 => true, DnsServer::Cloudflare(inner) => inner.validate(errors), DnsServer::DigitalOcean(inner) => inner.validate(errors), DnsServer::DeSEC(inner) => inner.validate(errors), @@ -10212,6 +10212,64 @@ impl ObjectImpl for DnsServer { DnsServer::Spaceship(inner) => inner.validate(errors), DnsServer::Route53(inner) => inner.validate(errors), DnsServer::GoogleCloudDns(inner) => inner.validate(errors), + DnsServer::Alidns(inner) => inner.validate(errors), + DnsServer::ArvanCloud(inner) => inner.validate(errors), + DnsServer::Autodns(inner) => inner.validate(errors), + DnsServer::AzureDns(inner) => inner.validate(errors), + DnsServer::BaiduCloud(inner) => inner.validate(errors), + DnsServer::BluecatV2(inner) => inner.validate(errors), + DnsServer::ClouDns(inner) => inner.validate(errors), + DnsServer::Constellix(inner) => inner.validate(errors), + DnsServer::Cpanel(inner) => inner.validate(errors), + DnsServer::Ddnss(inner) => inner.validate(errors), + DnsServer::DnsMadeEasy(inner) => inner.validate(errors), + DnsServer::Domeneshop(inner) => inner.validate(errors), + DnsServer::Dreamhost(inner) => inner.validate(errors), + DnsServer::DuckDns(inner) => inner.validate(errors), + DnsServer::Dynu(inner) => inner.validate(errors), + DnsServer::EasyDns(inner) => inner.validate(errors), + DnsServer::EdgeDns(inner) => inner.validate(errors), + DnsServer::Exoscale(inner) => inner.validate(errors), + DnsServer::FreeMyIp(inner) => inner.validate(errors), + DnsServer::GandiV5(inner) => inner.validate(errors), + DnsServer::Gcore(inner) => inner.validate(errors), + DnsServer::Glesys(inner) => inner.validate(errors), + DnsServer::Godaddy(inner) => inner.validate(errors), + DnsServer::Hetzner(inner) => inner.validate(errors), + DnsServer::HostingDe(inner) => inner.validate(errors), + DnsServer::Hostinger(inner) => inner.validate(errors), + DnsServer::HuaweiCloud(inner) => inner.validate(errors), + DnsServer::Hurricane(inner) => inner.validate(errors), + DnsServer::IbmCloud(inner) => inner.validate(errors), + DnsServer::Infoblox(inner) => inner.validate(errors), + DnsServer::Infomaniak(inner) => inner.validate(errors), + DnsServer::Inwx(inner) => inner.validate(errors), + DnsServer::Ionos(inner) => inner.validate(errors), + DnsServer::Ipv64(inner) => inner.validate(errors), + DnsServer::Joker(inner) => inner.validate(errors), + DnsServer::Lightsail(inner) => inner.validate(errors), + DnsServer::Linode(inner) => inner.validate(errors), + DnsServer::LuaDns(inner) => inner.validate(errors), + DnsServer::MythicBeasts(inner) => inner.validate(errors), + DnsServer::Namecheap(inner) => inner.validate(errors), + DnsServer::NameDotCom(inner) => inner.validate(errors), + DnsServer::NameSilo(inner) => inner.validate(errors), + DnsServer::Netcup(inner) => inner.validate(errors), + DnsServer::Netlify(inner) => inner.validate(errors), + DnsServer::Nifcloud(inner) => inner.validate(errors), + DnsServer::Ns1(inner) => inner.validate(errors), + DnsServer::OracleCloud(inner) => inner.validate(errors), + DnsServer::Plesk(inner) => inner.validate(errors), + DnsServer::Safedns(inner) => inner.validate(errors), + DnsServer::Scaleway(inner) => inner.validate(errors), + DnsServer::TencentCloud(inner) => inner.validate(errors), + DnsServer::Transip(inner) => inner.validate(errors), + DnsServer::UltraDns(inner) => inner.validate(errors), + DnsServer::Vercel(inner) => inner.validate(errors), + DnsServer::Volcengine(inner) => inner.validate(errors), + DnsServer::Vultr(inner) => inner.validate(errors), + DnsServer::WebSupport(inner) => inner.validate(errors), + DnsServer::YandexCloud(inner) => inner.validate(errors), } } @@ -10220,9 +10278,7 @@ impl ObjectImpl for DnsServer { DnsServer::Tsig(object) => { object.index(i); } - DnsServer::Sig0(object) => { - object.index(i); - } + DnsServer::Deprecated1 => {} DnsServer::Cloudflare(object) => { object.index(i); } @@ -10253,6 +10309,180 @@ impl ObjectImpl for DnsServer { DnsServer::GoogleCloudDns(object) => { object.index(i); } + DnsServer::Alidns(object) => { + object.index(i); + } + DnsServer::ArvanCloud(object) => { + object.index(i); + } + DnsServer::Autodns(object) => { + object.index(i); + } + DnsServer::AzureDns(object) => { + object.index(i); + } + DnsServer::BaiduCloud(object) => { + object.index(i); + } + DnsServer::BluecatV2(object) => { + object.index(i); + } + DnsServer::ClouDns(object) => { + object.index(i); + } + DnsServer::Constellix(object) => { + object.index(i); + } + DnsServer::Cpanel(object) => { + object.index(i); + } + DnsServer::Ddnss(object) => { + object.index(i); + } + DnsServer::DnsMadeEasy(object) => { + object.index(i); + } + DnsServer::Domeneshop(object) => { + object.index(i); + } + DnsServer::Dreamhost(object) => { + object.index(i); + } + DnsServer::DuckDns(object) => { + object.index(i); + } + DnsServer::Dynu(object) => { + object.index(i); + } + DnsServer::EasyDns(object) => { + object.index(i); + } + DnsServer::EdgeDns(object) => { + object.index(i); + } + DnsServer::Exoscale(object) => { + object.index(i); + } + DnsServer::FreeMyIp(object) => { + object.index(i); + } + DnsServer::GandiV5(object) => { + object.index(i); + } + DnsServer::Gcore(object) => { + object.index(i); + } + DnsServer::Glesys(object) => { + object.index(i); + } + DnsServer::Godaddy(object) => { + object.index(i); + } + DnsServer::Hetzner(object) => { + object.index(i); + } + DnsServer::HostingDe(object) => { + object.index(i); + } + DnsServer::Hostinger(object) => { + object.index(i); + } + DnsServer::HuaweiCloud(object) => { + object.index(i); + } + DnsServer::Hurricane(object) => { + object.index(i); + } + DnsServer::IbmCloud(object) => { + object.index(i); + } + DnsServer::Infoblox(object) => { + object.index(i); + } + DnsServer::Infomaniak(object) => { + object.index(i); + } + DnsServer::Inwx(object) => { + object.index(i); + } + DnsServer::Ionos(object) => { + object.index(i); + } + DnsServer::Ipv64(object) => { + object.index(i); + } + DnsServer::Joker(object) => { + object.index(i); + } + DnsServer::Lightsail(object) => { + object.index(i); + } + DnsServer::Linode(object) => { + object.index(i); + } + DnsServer::LuaDns(object) => { + object.index(i); + } + DnsServer::MythicBeasts(object) => { + object.index(i); + } + DnsServer::Namecheap(object) => { + object.index(i); + } + DnsServer::NameDotCom(object) => { + object.index(i); + } + DnsServer::NameSilo(object) => { + object.index(i); + } + DnsServer::Netcup(object) => { + object.index(i); + } + DnsServer::Netlify(object) => { + object.index(i); + } + DnsServer::Nifcloud(object) => { + object.index(i); + } + DnsServer::Ns1(object) => { + object.index(i); + } + DnsServer::OracleCloud(object) => { + object.index(i); + } + DnsServer::Plesk(object) => { + object.index(i); + } + DnsServer::Safedns(object) => { + object.index(i); + } + DnsServer::Scaleway(object) => { + object.index(i); + } + DnsServer::TencentCloud(object) => { + object.index(i); + } + DnsServer::Transip(object) => { + object.index(i); + } + DnsServer::UltraDns(object) => { + object.index(i); + } + DnsServer::Vercel(object) => { + object.index(i); + } + DnsServer::Volcengine(object) => { + object.index(i); + } + DnsServer::Vultr(object) => { + object.index(i); + } + DnsServer::WebSupport(object) => { + object.index(i); + } + DnsServer::YandexCloud(object) => { + object.index(i); + } } } } @@ -10270,9 +10500,8 @@ impl Pickle for DnsServer { 0u16.pickle(out); inner.pickle(out); } - DnsServer::Sig0(inner) => { + DnsServer::Deprecated1 => { 1u16.pickle(out); - inner.pickle(out); } DnsServer::Cloudflare(inner) => { 2u16.pickle(out); @@ -10314,13 +10543,245 @@ impl Pickle for DnsServer { 11u16.pickle(out); inner.pickle(out); } + DnsServer::Alidns(inner) => { + 12u16.pickle(out); + inner.pickle(out); + } + DnsServer::ArvanCloud(inner) => { + 13u16.pickle(out); + inner.pickle(out); + } + DnsServer::Autodns(inner) => { + 14u16.pickle(out); + inner.pickle(out); + } + DnsServer::AzureDns(inner) => { + 15u16.pickle(out); + inner.pickle(out); + } + DnsServer::BaiduCloud(inner) => { + 16u16.pickle(out); + inner.pickle(out); + } + DnsServer::BluecatV2(inner) => { + 17u16.pickle(out); + inner.pickle(out); + } + DnsServer::ClouDns(inner) => { + 18u16.pickle(out); + inner.pickle(out); + } + DnsServer::Constellix(inner) => { + 19u16.pickle(out); + inner.pickle(out); + } + DnsServer::Cpanel(inner) => { + 20u16.pickle(out); + inner.pickle(out); + } + DnsServer::Ddnss(inner) => { + 21u16.pickle(out); + inner.pickle(out); + } + DnsServer::DnsMadeEasy(inner) => { + 22u16.pickle(out); + inner.pickle(out); + } + DnsServer::Domeneshop(inner) => { + 23u16.pickle(out); + inner.pickle(out); + } + DnsServer::Dreamhost(inner) => { + 24u16.pickle(out); + inner.pickle(out); + } + DnsServer::DuckDns(inner) => { + 25u16.pickle(out); + inner.pickle(out); + } + DnsServer::Dynu(inner) => { + 26u16.pickle(out); + inner.pickle(out); + } + DnsServer::EasyDns(inner) => { + 27u16.pickle(out); + inner.pickle(out); + } + DnsServer::EdgeDns(inner) => { + 28u16.pickle(out); + inner.pickle(out); + } + DnsServer::Exoscale(inner) => { + 29u16.pickle(out); + inner.pickle(out); + } + DnsServer::FreeMyIp(inner) => { + 30u16.pickle(out); + inner.pickle(out); + } + DnsServer::GandiV5(inner) => { + 31u16.pickle(out); + inner.pickle(out); + } + DnsServer::Gcore(inner) => { + 32u16.pickle(out); + inner.pickle(out); + } + DnsServer::Glesys(inner) => { + 33u16.pickle(out); + inner.pickle(out); + } + DnsServer::Godaddy(inner) => { + 34u16.pickle(out); + inner.pickle(out); + } + DnsServer::Hetzner(inner) => { + 35u16.pickle(out); + inner.pickle(out); + } + DnsServer::HostingDe(inner) => { + 36u16.pickle(out); + inner.pickle(out); + } + DnsServer::Hostinger(inner) => { + 37u16.pickle(out); + inner.pickle(out); + } + DnsServer::HuaweiCloud(inner) => { + 38u16.pickle(out); + inner.pickle(out); + } + DnsServer::Hurricane(inner) => { + 39u16.pickle(out); + inner.pickle(out); + } + DnsServer::IbmCloud(inner) => { + 40u16.pickle(out); + inner.pickle(out); + } + DnsServer::Infoblox(inner) => { + 41u16.pickle(out); + inner.pickle(out); + } + DnsServer::Infomaniak(inner) => { + 42u16.pickle(out); + inner.pickle(out); + } + DnsServer::Inwx(inner) => { + 43u16.pickle(out); + inner.pickle(out); + } + DnsServer::Ionos(inner) => { + 44u16.pickle(out); + inner.pickle(out); + } + DnsServer::Ipv64(inner) => { + 45u16.pickle(out); + inner.pickle(out); + } + DnsServer::Joker(inner) => { + 46u16.pickle(out); + inner.pickle(out); + } + DnsServer::Lightsail(inner) => { + 47u16.pickle(out); + inner.pickle(out); + } + DnsServer::Linode(inner) => { + 48u16.pickle(out); + inner.pickle(out); + } + DnsServer::LuaDns(inner) => { + 49u16.pickle(out); + inner.pickle(out); + } + DnsServer::MythicBeasts(inner) => { + 50u16.pickle(out); + inner.pickle(out); + } + DnsServer::Namecheap(inner) => { + 51u16.pickle(out); + inner.pickle(out); + } + DnsServer::NameDotCom(inner) => { + 52u16.pickle(out); + inner.pickle(out); + } + DnsServer::NameSilo(inner) => { + 53u16.pickle(out); + inner.pickle(out); + } + DnsServer::Netcup(inner) => { + 54u16.pickle(out); + inner.pickle(out); + } + DnsServer::Netlify(inner) => { + 55u16.pickle(out); + inner.pickle(out); + } + DnsServer::Nifcloud(inner) => { + 56u16.pickle(out); + inner.pickle(out); + } + DnsServer::Ns1(inner) => { + 57u16.pickle(out); + inner.pickle(out); + } + DnsServer::OracleCloud(inner) => { + 58u16.pickle(out); + inner.pickle(out); + } + DnsServer::Plesk(inner) => { + 59u16.pickle(out); + inner.pickle(out); + } + DnsServer::Safedns(inner) => { + 60u16.pickle(out); + inner.pickle(out); + } + DnsServer::Scaleway(inner) => { + 61u16.pickle(out); + inner.pickle(out); + } + DnsServer::TencentCloud(inner) => { + 62u16.pickle(out); + inner.pickle(out); + } + DnsServer::Transip(inner) => { + 63u16.pickle(out); + inner.pickle(out); + } + DnsServer::UltraDns(inner) => { + 64u16.pickle(out); + inner.pickle(out); + } + DnsServer::Vercel(inner) => { + 65u16.pickle(out); + inner.pickle(out); + } + DnsServer::Volcengine(inner) => { + 66u16.pickle(out); + inner.pickle(out); + } + DnsServer::Vultr(inner) => { + 67u16.pickle(out); + inner.pickle(out); + } + DnsServer::WebSupport(inner) => { + 68u16.pickle(out); + inner.pickle(out); + } + DnsServer::YandexCloud(inner) => { + 69u16.pickle(out); + inner.pickle(out); + } } } fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { match u16::unpickle(stream)? { 0 => Pickle::unpickle(stream).map(DnsServer::Tsig), - 1 => Pickle::unpickle(stream).map(DnsServer::Sig0), + 1 => Some(DnsServer::Deprecated1), 2 => Pickle::unpickle(stream).map(DnsServer::Cloudflare), 3 => Pickle::unpickle(stream).map(DnsServer::DigitalOcean), 4 => Pickle::unpickle(stream).map(DnsServer::DeSEC), @@ -10331,6 +10792,64 @@ impl Pickle for DnsServer { 9 => Pickle::unpickle(stream).map(DnsServer::Spaceship), 10 => Pickle::unpickle(stream).map(DnsServer::Route53), 11 => Pickle::unpickle(stream).map(DnsServer::GoogleCloudDns), + 12 => Pickle::unpickle(stream).map(DnsServer::Alidns), + 13 => Pickle::unpickle(stream).map(DnsServer::ArvanCloud), + 14 => Pickle::unpickle(stream).map(DnsServer::Autodns), + 15 => Pickle::unpickle(stream).map(DnsServer::AzureDns), + 16 => Pickle::unpickle(stream).map(DnsServer::BaiduCloud), + 17 => Pickle::unpickle(stream).map(DnsServer::BluecatV2), + 18 => Pickle::unpickle(stream).map(DnsServer::ClouDns), + 19 => Pickle::unpickle(stream).map(DnsServer::Constellix), + 20 => Pickle::unpickle(stream).map(DnsServer::Cpanel), + 21 => Pickle::unpickle(stream).map(DnsServer::Ddnss), + 22 => Pickle::unpickle(stream).map(DnsServer::DnsMadeEasy), + 23 => Pickle::unpickle(stream).map(DnsServer::Domeneshop), + 24 => Pickle::unpickle(stream).map(DnsServer::Dreamhost), + 25 => Pickle::unpickle(stream).map(DnsServer::DuckDns), + 26 => Pickle::unpickle(stream).map(DnsServer::Dynu), + 27 => Pickle::unpickle(stream).map(DnsServer::EasyDns), + 28 => Pickle::unpickle(stream).map(DnsServer::EdgeDns), + 29 => Pickle::unpickle(stream).map(DnsServer::Exoscale), + 30 => Pickle::unpickle(stream).map(DnsServer::FreeMyIp), + 31 => Pickle::unpickle(stream).map(DnsServer::GandiV5), + 32 => Pickle::unpickle(stream).map(DnsServer::Gcore), + 33 => Pickle::unpickle(stream).map(DnsServer::Glesys), + 34 => Pickle::unpickle(stream).map(DnsServer::Godaddy), + 35 => Pickle::unpickle(stream).map(DnsServer::Hetzner), + 36 => Pickle::unpickle(stream).map(DnsServer::HostingDe), + 37 => Pickle::unpickle(stream).map(DnsServer::Hostinger), + 38 => Pickle::unpickle(stream).map(DnsServer::HuaweiCloud), + 39 => Pickle::unpickle(stream).map(DnsServer::Hurricane), + 40 => Pickle::unpickle(stream).map(DnsServer::IbmCloud), + 41 => Pickle::unpickle(stream).map(DnsServer::Infoblox), + 42 => Pickle::unpickle(stream).map(DnsServer::Infomaniak), + 43 => Pickle::unpickle(stream).map(DnsServer::Inwx), + 44 => Pickle::unpickle(stream).map(DnsServer::Ionos), + 45 => Pickle::unpickle(stream).map(DnsServer::Ipv64), + 46 => Pickle::unpickle(stream).map(DnsServer::Joker), + 47 => Pickle::unpickle(stream).map(DnsServer::Lightsail), + 48 => Pickle::unpickle(stream).map(DnsServer::Linode), + 49 => Pickle::unpickle(stream).map(DnsServer::LuaDns), + 50 => Pickle::unpickle(stream).map(DnsServer::MythicBeasts), + 51 => Pickle::unpickle(stream).map(DnsServer::Namecheap), + 52 => Pickle::unpickle(stream).map(DnsServer::NameDotCom), + 53 => Pickle::unpickle(stream).map(DnsServer::NameSilo), + 54 => Pickle::unpickle(stream).map(DnsServer::Netcup), + 55 => Pickle::unpickle(stream).map(DnsServer::Netlify), + 56 => Pickle::unpickle(stream).map(DnsServer::Nifcloud), + 57 => Pickle::unpickle(stream).map(DnsServer::Ns1), + 58 => Pickle::unpickle(stream).map(DnsServer::OracleCloud), + 59 => Pickle::unpickle(stream).map(DnsServer::Plesk), + 60 => Pickle::unpickle(stream).map(DnsServer::Safedns), + 61 => Pickle::unpickle(stream).map(DnsServer::Scaleway), + 62 => Pickle::unpickle(stream).map(DnsServer::TencentCloud), + 63 => Pickle::unpickle(stream).map(DnsServer::Transip), + 64 => Pickle::unpickle(stream).map(DnsServer::UltraDns), + 65 => Pickle::unpickle(stream).map(DnsServer::Vercel), + 66 => Pickle::unpickle(stream).map(DnsServer::Volcengine), + 67 => Pickle::unpickle(stream).map(DnsServer::Vultr), + 68 => Pickle::unpickle(stream).map(DnsServer::WebSupport), + 69 => Pickle::unpickle(stream).map(DnsServer::YandexCloud), _ => None, } } @@ -10346,12 +10865,10 @@ impl IntoValue for DnsServer { .insert_unchecked(Property::Type, JmapValue::Str("Tsig".into())); obj } - DnsServer::Sig0(obj) => { - let mut obj = obj.into_value(); - obj.as_object_mut() - .unwrap() - .insert_unchecked(Property::Type, JmapValue::Str("Sig0".into())); - obj + DnsServer::Deprecated1 => { + let mut obj = jmap_tools::Map::new(); + obj.insert_unchecked(Property::Type, JmapValue::Str("Deprecated1".into())); + JmapValue::Object(obj) } DnsServer::Cloudflare(obj) => { let mut obj = obj.into_value(); @@ -10423,6 +10940,412 @@ impl IntoValue for DnsServer { .insert_unchecked(Property::Type, JmapValue::Str("GoogleCloudDns".into())); obj } + DnsServer::Alidns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Alidns".into())); + obj + } + DnsServer::ArvanCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("ArvanCloud".into())); + obj + } + DnsServer::Autodns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Autodns".into())); + obj + } + DnsServer::AzureDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("AzureDns".into())); + obj + } + DnsServer::BaiduCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("BaiduCloud".into())); + obj + } + DnsServer::BluecatV2(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("BluecatV2".into())); + obj + } + DnsServer::ClouDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("ClouDns".into())); + obj + } + DnsServer::Constellix(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Constellix".into())); + obj + } + DnsServer::Cpanel(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Cpanel".into())); + obj + } + DnsServer::Ddnss(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ddnss".into())); + obj + } + DnsServer::DnsMadeEasy(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("DnsMadeEasy".into())); + obj + } + DnsServer::Domeneshop(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Domeneshop".into())); + obj + } + DnsServer::Dreamhost(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Dreamhost".into())); + obj + } + DnsServer::DuckDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("DuckDns".into())); + obj + } + DnsServer::Dynu(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Dynu".into())); + obj + } + DnsServer::EasyDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("EasyDns".into())); + obj + } + DnsServer::EdgeDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("EdgeDns".into())); + obj + } + DnsServer::Exoscale(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Exoscale".into())); + obj + } + DnsServer::FreeMyIp(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("FreeMyIp".into())); + obj + } + DnsServer::GandiV5(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("GandiV5".into())); + obj + } + DnsServer::Gcore(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Gcore".into())); + obj + } + DnsServer::Glesys(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Glesys".into())); + obj + } + DnsServer::Godaddy(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Godaddy".into())); + obj + } + DnsServer::Hetzner(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hetzner".into())); + obj + } + DnsServer::HostingDe(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("HostingDe".into())); + obj + } + DnsServer::Hostinger(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hostinger".into())); + obj + } + DnsServer::HuaweiCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("HuaweiCloud".into())); + obj + } + DnsServer::Hurricane(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hurricane".into())); + obj + } + DnsServer::IbmCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("IbmCloud".into())); + obj + } + DnsServer::Infoblox(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Infoblox".into())); + obj + } + DnsServer::Infomaniak(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Infomaniak".into())); + obj + } + DnsServer::Inwx(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Inwx".into())); + obj + } + DnsServer::Ionos(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ionos".into())); + obj + } + DnsServer::Ipv64(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ipv64".into())); + obj + } + DnsServer::Joker(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Joker".into())); + obj + } + DnsServer::Lightsail(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Lightsail".into())); + obj + } + DnsServer::Linode(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Linode".into())); + obj + } + DnsServer::LuaDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("LuaDns".into())); + obj + } + DnsServer::MythicBeasts(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("MythicBeasts".into())); + obj + } + DnsServer::Namecheap(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Namecheap".into())); + obj + } + DnsServer::NameDotCom(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("NameDotCom".into())); + obj + } + DnsServer::NameSilo(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("NameSilo".into())); + obj + } + DnsServer::Netcup(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Netcup".into())); + obj + } + DnsServer::Netlify(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Netlify".into())); + obj + } + DnsServer::Nifcloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Nifcloud".into())); + obj + } + DnsServer::Ns1(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ns1".into())); + obj + } + DnsServer::OracleCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("OracleCloud".into())); + obj + } + DnsServer::Plesk(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Plesk".into())); + obj + } + DnsServer::Safedns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Safedns".into())); + obj + } + DnsServer::Scaleway(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Scaleway".into())); + obj + } + DnsServer::TencentCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("TencentCloud".into())); + obj + } + DnsServer::Transip(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Transip".into())); + obj + } + DnsServer::UltraDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("UltraDns".into())); + obj + } + DnsServer::Vercel(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Vercel".into())); + obj + } + DnsServer::Volcengine(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Volcengine".into())); + obj + } + DnsServer::Vultr(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Vultr".into())); + obj + } + DnsServer::WebSupport(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("WebSupport".into())); + obj + } + DnsServer::YandexCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("YandexCloud".into())); + obj + } } } } @@ -10436,7 +11359,7 @@ impl RegistryJsonPatch for DnsServer { if !pointer.has_next() { match object_type(&pointer, &value)? { DnsServerType::Tsig => *self = DnsServer::Tsig(Default::default()), - DnsServerType::Sig0 => *self = DnsServer::Sig0(Default::default()), + DnsServerType::Deprecated1 => *self = DnsServer::Deprecated1, DnsServerType::Cloudflare => *self = DnsServer::Cloudflare(Default::default()), DnsServerType::DigitalOcean => *self = DnsServer::DigitalOcean(Default::default()), DnsServerType::DeSEC => *self = DnsServer::DeSEC(Default::default()), @@ -10449,11 +11372,69 @@ impl RegistryJsonPatch for DnsServer { DnsServerType::GoogleCloudDns => { *self = DnsServer::GoogleCloudDns(Default::default()) } + DnsServerType::Alidns => *self = DnsServer::Alidns(Default::default()), + DnsServerType::ArvanCloud => *self = DnsServer::ArvanCloud(Default::default()), + DnsServerType::Autodns => *self = DnsServer::Autodns(Default::default()), + DnsServerType::AzureDns => *self = DnsServer::AzureDns(Default::default()), + DnsServerType::BaiduCloud => *self = DnsServer::BaiduCloud(Default::default()), + DnsServerType::BluecatV2 => *self = DnsServer::BluecatV2(Default::default()), + DnsServerType::ClouDns => *self = DnsServer::ClouDns(Default::default()), + DnsServerType::Constellix => *self = DnsServer::Constellix(Default::default()), + DnsServerType::Cpanel => *self = DnsServer::Cpanel(Default::default()), + DnsServerType::Ddnss => *self = DnsServer::Ddnss(Default::default()), + DnsServerType::DnsMadeEasy => *self = DnsServer::DnsMadeEasy(Default::default()), + DnsServerType::Domeneshop => *self = DnsServer::Domeneshop(Default::default()), + DnsServerType::Dreamhost => *self = DnsServer::Dreamhost(Default::default()), + DnsServerType::DuckDns => *self = DnsServer::DuckDns(Default::default()), + DnsServerType::Dynu => *self = DnsServer::Dynu(Default::default()), + DnsServerType::EasyDns => *self = DnsServer::EasyDns(Default::default()), + DnsServerType::EdgeDns => *self = DnsServer::EdgeDns(Default::default()), + DnsServerType::Exoscale => *self = DnsServer::Exoscale(Default::default()), + DnsServerType::FreeMyIp => *self = DnsServer::FreeMyIp(Default::default()), + DnsServerType::GandiV5 => *self = DnsServer::GandiV5(Default::default()), + DnsServerType::Gcore => *self = DnsServer::Gcore(Default::default()), + DnsServerType::Glesys => *self = DnsServer::Glesys(Default::default()), + DnsServerType::Godaddy => *self = DnsServer::Godaddy(Default::default()), + DnsServerType::Hetzner => *self = DnsServer::Hetzner(Default::default()), + DnsServerType::HostingDe => *self = DnsServer::HostingDe(Default::default()), + DnsServerType::Hostinger => *self = DnsServer::Hostinger(Default::default()), + DnsServerType::HuaweiCloud => *self = DnsServer::HuaweiCloud(Default::default()), + DnsServerType::Hurricane => *self = DnsServer::Hurricane(Default::default()), + DnsServerType::IbmCloud => *self = DnsServer::IbmCloud(Default::default()), + DnsServerType::Infoblox => *self = DnsServer::Infoblox(Default::default()), + DnsServerType::Infomaniak => *self = DnsServer::Infomaniak(Default::default()), + DnsServerType::Inwx => *self = DnsServer::Inwx(Default::default()), + DnsServerType::Ionos => *self = DnsServer::Ionos(Default::default()), + DnsServerType::Ipv64 => *self = DnsServer::Ipv64(Default::default()), + DnsServerType::Joker => *self = DnsServer::Joker(Default::default()), + DnsServerType::Lightsail => *self = DnsServer::Lightsail(Default::default()), + DnsServerType::Linode => *self = DnsServer::Linode(Default::default()), + DnsServerType::LuaDns => *self = DnsServer::LuaDns(Default::default()), + DnsServerType::MythicBeasts => *self = DnsServer::MythicBeasts(Default::default()), + DnsServerType::Namecheap => *self = DnsServer::Namecheap(Default::default()), + DnsServerType::NameDotCom => *self = DnsServer::NameDotCom(Default::default()), + DnsServerType::NameSilo => *self = DnsServer::NameSilo(Default::default()), + DnsServerType::Netcup => *self = DnsServer::Netcup(Default::default()), + DnsServerType::Netlify => *self = DnsServer::Netlify(Default::default()), + DnsServerType::Nifcloud => *self = DnsServer::Nifcloud(Default::default()), + DnsServerType::Ns1 => *self = DnsServer::Ns1(Default::default()), + DnsServerType::OracleCloud => *self = DnsServer::OracleCloud(Default::default()), + DnsServerType::Plesk => *self = DnsServer::Plesk(Default::default()), + DnsServerType::Safedns => *self = DnsServer::Safedns(Default::default()), + DnsServerType::Scaleway => *self = DnsServer::Scaleway(Default::default()), + DnsServerType::TencentCloud => *self = DnsServer::TencentCloud(Default::default()), + DnsServerType::Transip => *self = DnsServer::Transip(Default::default()), + DnsServerType::UltraDns => *self = DnsServer::UltraDns(Default::default()), + DnsServerType::Vercel => *self = DnsServer::Vercel(Default::default()), + DnsServerType::Volcengine => *self = DnsServer::Volcengine(Default::default()), + DnsServerType::Vultr => *self = DnsServer::Vultr(Default::default()), + DnsServerType::WebSupport => *self = DnsServer::WebSupport(Default::default()), + DnsServerType::YandexCloud => *self = DnsServer::YandexCloud(Default::default()), } } match self { DnsServer::Tsig(inner) => inner.patch(pointer, value), - DnsServer::Sig0(inner) => inner.patch(pointer, value), + DnsServer::Deprecated1 => pointer.assert_eof(), DnsServer::Cloudflare(inner) => inner.patch(pointer, value), DnsServer::DigitalOcean(inner) => inner.patch(pointer, value), DnsServer::DeSEC(inner) => inner.patch(pointer, value), @@ -10464,6 +11445,64 @@ impl RegistryJsonPatch for DnsServer { DnsServer::Spaceship(inner) => inner.patch(pointer, value), DnsServer::Route53(inner) => inner.patch(pointer, value), DnsServer::GoogleCloudDns(inner) => inner.patch(pointer, value), + DnsServer::Alidns(inner) => inner.patch(pointer, value), + DnsServer::ArvanCloud(inner) => inner.patch(pointer, value), + DnsServer::Autodns(inner) => inner.patch(pointer, value), + DnsServer::AzureDns(inner) => inner.patch(pointer, value), + DnsServer::BaiduCloud(inner) => inner.patch(pointer, value), + DnsServer::BluecatV2(inner) => inner.patch(pointer, value), + DnsServer::ClouDns(inner) => inner.patch(pointer, value), + DnsServer::Constellix(inner) => inner.patch(pointer, value), + DnsServer::Cpanel(inner) => inner.patch(pointer, value), + DnsServer::Ddnss(inner) => inner.patch(pointer, value), + DnsServer::DnsMadeEasy(inner) => inner.patch(pointer, value), + DnsServer::Domeneshop(inner) => inner.patch(pointer, value), + DnsServer::Dreamhost(inner) => inner.patch(pointer, value), + DnsServer::DuckDns(inner) => inner.patch(pointer, value), + DnsServer::Dynu(inner) => inner.patch(pointer, value), + DnsServer::EasyDns(inner) => inner.patch(pointer, value), + DnsServer::EdgeDns(inner) => inner.patch(pointer, value), + DnsServer::Exoscale(inner) => inner.patch(pointer, value), + DnsServer::FreeMyIp(inner) => inner.patch(pointer, value), + DnsServer::GandiV5(inner) => inner.patch(pointer, value), + DnsServer::Gcore(inner) => inner.patch(pointer, value), + DnsServer::Glesys(inner) => inner.patch(pointer, value), + DnsServer::Godaddy(inner) => inner.patch(pointer, value), + DnsServer::Hetzner(inner) => inner.patch(pointer, value), + DnsServer::HostingDe(inner) => inner.patch(pointer, value), + DnsServer::Hostinger(inner) => inner.patch(pointer, value), + DnsServer::HuaweiCloud(inner) => inner.patch(pointer, value), + DnsServer::Hurricane(inner) => inner.patch(pointer, value), + DnsServer::IbmCloud(inner) => inner.patch(pointer, value), + DnsServer::Infoblox(inner) => inner.patch(pointer, value), + DnsServer::Infomaniak(inner) => inner.patch(pointer, value), + DnsServer::Inwx(inner) => inner.patch(pointer, value), + DnsServer::Ionos(inner) => inner.patch(pointer, value), + DnsServer::Ipv64(inner) => inner.patch(pointer, value), + DnsServer::Joker(inner) => inner.patch(pointer, value), + DnsServer::Lightsail(inner) => inner.patch(pointer, value), + DnsServer::Linode(inner) => inner.patch(pointer, value), + DnsServer::LuaDns(inner) => inner.patch(pointer, value), + DnsServer::MythicBeasts(inner) => inner.patch(pointer, value), + DnsServer::Namecheap(inner) => inner.patch(pointer, value), + DnsServer::NameDotCom(inner) => inner.patch(pointer, value), + DnsServer::NameSilo(inner) => inner.patch(pointer, value), + DnsServer::Netcup(inner) => inner.patch(pointer, value), + DnsServer::Netlify(inner) => inner.patch(pointer, value), + DnsServer::Nifcloud(inner) => inner.patch(pointer, value), + DnsServer::Ns1(inner) => inner.patch(pointer, value), + DnsServer::OracleCloud(inner) => inner.patch(pointer, value), + DnsServer::Plesk(inner) => inner.patch(pointer, value), + DnsServer::Safedns(inner) => inner.patch(pointer, value), + DnsServer::Scaleway(inner) => inner.patch(pointer, value), + DnsServer::TencentCloud(inner) => inner.patch(pointer, value), + DnsServer::Transip(inner) => inner.patch(pointer, value), + DnsServer::UltraDns(inner) => inner.patch(pointer, value), + DnsServer::Vercel(inner) => inner.patch(pointer, value), + DnsServer::Volcengine(inner) => inner.patch(pointer, value), + DnsServer::Vultr(inner) => inner.patch(pointer, value), + DnsServer::WebSupport(inner) => inner.patch(pointer, value), + DnsServer::YandexCloud(inner) => inner.patch(pointer, value), } } } @@ -10472,7 +11511,7 @@ impl DnsServer { pub fn object_type(&self) -> DnsServerType { match self { DnsServer::Tsig(_) => DnsServerType::Tsig, - DnsServer::Sig0(_) => DnsServerType::Sig0, + DnsServer::Deprecated1 => DnsServerType::Deprecated1, DnsServer::Cloudflare(_) => DnsServerType::Cloudflare, DnsServer::DigitalOcean(_) => DnsServerType::DigitalOcean, DnsServer::DeSEC(_) => DnsServerType::DeSEC, @@ -10483,6 +11522,821 @@ impl DnsServer { DnsServer::Spaceship(_) => DnsServerType::Spaceship, DnsServer::Route53(_) => DnsServerType::Route53, DnsServer::GoogleCloudDns(_) => DnsServerType::GoogleCloudDns, + DnsServer::Alidns(_) => DnsServerType::Alidns, + DnsServer::ArvanCloud(_) => DnsServerType::ArvanCloud, + DnsServer::Autodns(_) => DnsServerType::Autodns, + DnsServer::AzureDns(_) => DnsServerType::AzureDns, + DnsServer::BaiduCloud(_) => DnsServerType::BaiduCloud, + DnsServer::BluecatV2(_) => DnsServerType::BluecatV2, + DnsServer::ClouDns(_) => DnsServerType::ClouDns, + DnsServer::Constellix(_) => DnsServerType::Constellix, + DnsServer::Cpanel(_) => DnsServerType::Cpanel, + DnsServer::Ddnss(_) => DnsServerType::Ddnss, + DnsServer::DnsMadeEasy(_) => DnsServerType::DnsMadeEasy, + DnsServer::Domeneshop(_) => DnsServerType::Domeneshop, + DnsServer::Dreamhost(_) => DnsServerType::Dreamhost, + DnsServer::DuckDns(_) => DnsServerType::DuckDns, + DnsServer::Dynu(_) => DnsServerType::Dynu, + DnsServer::EasyDns(_) => DnsServerType::EasyDns, + DnsServer::EdgeDns(_) => DnsServerType::EdgeDns, + DnsServer::Exoscale(_) => DnsServerType::Exoscale, + DnsServer::FreeMyIp(_) => DnsServerType::FreeMyIp, + DnsServer::GandiV5(_) => DnsServerType::GandiV5, + DnsServer::Gcore(_) => DnsServerType::Gcore, + DnsServer::Glesys(_) => DnsServerType::Glesys, + DnsServer::Godaddy(_) => DnsServerType::Godaddy, + DnsServer::Hetzner(_) => DnsServerType::Hetzner, + DnsServer::HostingDe(_) => DnsServerType::HostingDe, + DnsServer::Hostinger(_) => DnsServerType::Hostinger, + DnsServer::HuaweiCloud(_) => DnsServerType::HuaweiCloud, + DnsServer::Hurricane(_) => DnsServerType::Hurricane, + DnsServer::IbmCloud(_) => DnsServerType::IbmCloud, + DnsServer::Infoblox(_) => DnsServerType::Infoblox, + DnsServer::Infomaniak(_) => DnsServerType::Infomaniak, + DnsServer::Inwx(_) => DnsServerType::Inwx, + DnsServer::Ionos(_) => DnsServerType::Ionos, + DnsServer::Ipv64(_) => DnsServerType::Ipv64, + DnsServer::Joker(_) => DnsServerType::Joker, + DnsServer::Lightsail(_) => DnsServerType::Lightsail, + DnsServer::Linode(_) => DnsServerType::Linode, + DnsServer::LuaDns(_) => DnsServerType::LuaDns, + DnsServer::MythicBeasts(_) => DnsServerType::MythicBeasts, + DnsServer::Namecheap(_) => DnsServerType::Namecheap, + DnsServer::NameDotCom(_) => DnsServerType::NameDotCom, + DnsServer::NameSilo(_) => DnsServerType::NameSilo, + DnsServer::Netcup(_) => DnsServerType::Netcup, + DnsServer::Netlify(_) => DnsServerType::Netlify, + DnsServer::Nifcloud(_) => DnsServerType::Nifcloud, + DnsServer::Ns1(_) => DnsServerType::Ns1, + DnsServer::OracleCloud(_) => DnsServerType::OracleCloud, + DnsServer::Plesk(_) => DnsServerType::Plesk, + DnsServer::Safedns(_) => DnsServerType::Safedns, + DnsServer::Scaleway(_) => DnsServerType::Scaleway, + DnsServer::TencentCloud(_) => DnsServerType::TencentCloud, + DnsServer::Transip(_) => DnsServerType::Transip, + DnsServer::UltraDns(_) => DnsServerType::UltraDns, + DnsServer::Vercel(_) => DnsServerType::Vercel, + DnsServer::Volcengine(_) => DnsServerType::Volcengine, + DnsServer::Vultr(_) => DnsServerType::Vultr, + DnsServer::WebSupport(_) => DnsServerType::WebSupport, + DnsServer::YandexCloud(_) => DnsServerType::YandexCloud, + } + } +} + +impl DnsServerAlidns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKey)); + } + let value = &self.secret_key; + value.validate(errors); + if let Some(value) = &self.region { + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + } + let value = &self.security_token; + value.validate(errors); + if let Some(value) = &self.line { + if value.is_empty() { + errors.push(ValidationError::required(Property::Line)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerAlidns { + fn pickle(&self, out: &mut Vec) { + self.access_key.pickle(out); + self.secret_key.pickle(out); + self.region.pickle(out); + self.security_token.pickle(out); + self.line.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.security_token = Pickle::unpickle(stream)?; + this.line = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerAlidns { + fn default() -> Self { + Self { + access_key: Default::default(), + secret_key: Default::default(), + region: Default::default(), + security_token: Default::default(), + line: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerAlidns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(14); + map.insert_unchecked(Property::AccessKey, self.access_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked(Property::SecurityToken, self.security_token.into_value()); + map.insert_unchecked(Property::Line, self.line.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerAlidns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKey) => self + .access_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecurityToken) => self.security_token.patch(pointer, value), + Some(Property::Line) => self + .line + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerAutodns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerAutodns { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.password.pickle(out); + self.context.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.context = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerAutodns { + fn default() -> Self { + Self { + username: Default::default(), + password: Default::default(), + context: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerAutodns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::Context, self.context.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerAutodns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Context) => self.context.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerAzureDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.tenant_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::TenantId)); + } + let value = &self.client_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::ClientId)); + } + let value = &self.client_secret; + value.validate(errors); + let value = &self.subscription_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::SubscriptionId)); + } + let value = &self.resource_group; + if value.is_empty() { + errors.push(ValidationError::required(Property::ResourceGroup)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerAzureDns { + fn pickle(&self, out: &mut Vec) { + self.tenant_id.pickle(out); + self.client_id.pickle(out); + self.client_secret.pickle(out); + self.subscription_id.pickle(out); + self.resource_group.pickle(out); + self.environment.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.tenant_id = Pickle::unpickle(stream)?; + this.client_id = Pickle::unpickle(stream)?; + this.client_secret = Pickle::unpickle(stream)?; + this.subscription_id = Pickle::unpickle(stream)?; + this.resource_group = Pickle::unpickle(stream)?; + this.environment = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerAzureDns { + fn default() -> Self { + Self { + tenant_id: Default::default(), + client_id: Default::default(), + client_secret: Default::default(), + subscription_id: Default::default(), + resource_group: Default::default(), + environment: AzureEnvironment::Public, + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerAzureDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(15); + map.insert_unchecked(Property::TenantId, self.tenant_id.into_value()); + map.insert_unchecked(Property::ClientId, self.client_id.into_value()); + map.insert_unchecked(Property::ClientSecret, self.client_secret.into_value()); + map.insert_unchecked(Property::SubscriptionId, self.subscription_id.into_value()); + map.insert_unchecked(Property::ResourceGroup, self.resource_group.into_value()); + map.insert_unchecked(Property::Environment, self.environment.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerAzureDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::TenantId) => self + .tenant_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ClientId) => self + .client_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ClientSecret) => self.client_secret.patch(pointer, value), + Some(Property::SubscriptionId) => self + .subscription_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ResourceGroup) => self + .resource_group + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Environment) => self.environment.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerBaiduCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKey)); + } + let value = &self.secret_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerBaiduCloud { + fn pickle(&self, out: &mut Vec) { + self.access_key.pickle(out); + self.secret_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerBaiduCloud { + fn default() -> Self { + Self { + access_key: Default::default(), + secret_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerBaiduCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::AccessKey, self.access_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerBaiduCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKey) => self + .access_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerBluecatV2 { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.base_url; + if value.is_empty() { + errors.push(ValidationError::required(Property::BaseUrl)); + } + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + let value = &self.config_name; + if value.is_empty() { + errors.push(ValidationError::required(Property::ConfigName)); + } + let value = &self.view_name; + if value.is_empty() { + errors.push(ValidationError::required(Property::ViewName)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerBluecatV2 { + fn pickle(&self, out: &mut Vec) { + self.base_url.pickle(out); + self.username.pickle(out); + self.password.pickle(out); + self.config_name.pickle(out); + self.view_name.pickle(out); + self.skip_deploy.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.base_url = Pickle::unpickle(stream)?; + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.config_name = Pickle::unpickle(stream)?; + this.view_name = Pickle::unpickle(stream)?; + this.skip_deploy = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerBluecatV2 { + fn default() -> Self { + Self { + base_url: Default::default(), + username: Default::default(), + password: Default::default(), + config_name: Default::default(), + view_name: Default::default(), + skip_deploy: false, + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerBluecatV2 { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(15); + map.insert_unchecked(Property::BaseUrl, self.base_url.into_value()); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::ConfigName, self.config_name.into_value()); + map.insert_unchecked(Property::ViewName, self.view_name.into_value()); + map.insert_unchecked(Property::SkipDeploy, self.skip_deploy.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerBluecatV2 { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::BaseUrl) => self + .base_url + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::ConfigName) => self + .config_name + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ViewName) => self + .view_name + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SkipDeploy) => self.skip_deploy.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), } } } @@ -10492,7 +12346,7 @@ impl DnsServerBootstrap { match self { DnsServerBootstrap::Manual => true, DnsServerBootstrap::Tsig(inner) => inner.validate(errors), - DnsServerBootstrap::Sig0(inner) => inner.validate(errors), + DnsServerBootstrap::Deprecated1 => true, DnsServerBootstrap::Cloudflare(inner) => inner.validate(errors), DnsServerBootstrap::DigitalOcean(inner) => inner.validate(errors), DnsServerBootstrap::DeSEC(inner) => inner.validate(errors), @@ -10503,6 +12357,64 @@ impl DnsServerBootstrap { DnsServerBootstrap::Spaceship(inner) => inner.validate(errors), DnsServerBootstrap::Route53(inner) => inner.validate(errors), DnsServerBootstrap::GoogleCloudDns(inner) => inner.validate(errors), + DnsServerBootstrap::Alidns(inner) => inner.validate(errors), + DnsServerBootstrap::ArvanCloud(inner) => inner.validate(errors), + DnsServerBootstrap::Autodns(inner) => inner.validate(errors), + DnsServerBootstrap::AzureDns(inner) => inner.validate(errors), + DnsServerBootstrap::BaiduCloud(inner) => inner.validate(errors), + DnsServerBootstrap::BluecatV2(inner) => inner.validate(errors), + DnsServerBootstrap::ClouDns(inner) => inner.validate(errors), + DnsServerBootstrap::Constellix(inner) => inner.validate(errors), + DnsServerBootstrap::Cpanel(inner) => inner.validate(errors), + DnsServerBootstrap::Ddnss(inner) => inner.validate(errors), + DnsServerBootstrap::DnsMadeEasy(inner) => inner.validate(errors), + DnsServerBootstrap::Domeneshop(inner) => inner.validate(errors), + DnsServerBootstrap::Dreamhost(inner) => inner.validate(errors), + DnsServerBootstrap::DuckDns(inner) => inner.validate(errors), + DnsServerBootstrap::Dynu(inner) => inner.validate(errors), + DnsServerBootstrap::EasyDns(inner) => inner.validate(errors), + DnsServerBootstrap::EdgeDns(inner) => inner.validate(errors), + DnsServerBootstrap::Exoscale(inner) => inner.validate(errors), + DnsServerBootstrap::FreeMyIp(inner) => inner.validate(errors), + DnsServerBootstrap::GandiV5(inner) => inner.validate(errors), + DnsServerBootstrap::Gcore(inner) => inner.validate(errors), + DnsServerBootstrap::Glesys(inner) => inner.validate(errors), + DnsServerBootstrap::Godaddy(inner) => inner.validate(errors), + DnsServerBootstrap::Hetzner(inner) => inner.validate(errors), + DnsServerBootstrap::HostingDe(inner) => inner.validate(errors), + DnsServerBootstrap::Hostinger(inner) => inner.validate(errors), + DnsServerBootstrap::HuaweiCloud(inner) => inner.validate(errors), + DnsServerBootstrap::Hurricane(inner) => inner.validate(errors), + DnsServerBootstrap::IbmCloud(inner) => inner.validate(errors), + DnsServerBootstrap::Infoblox(inner) => inner.validate(errors), + DnsServerBootstrap::Infomaniak(inner) => inner.validate(errors), + DnsServerBootstrap::Inwx(inner) => inner.validate(errors), + DnsServerBootstrap::Ionos(inner) => inner.validate(errors), + DnsServerBootstrap::Ipv64(inner) => inner.validate(errors), + DnsServerBootstrap::Joker(inner) => inner.validate(errors), + DnsServerBootstrap::Lightsail(inner) => inner.validate(errors), + DnsServerBootstrap::Linode(inner) => inner.validate(errors), + DnsServerBootstrap::LuaDns(inner) => inner.validate(errors), + DnsServerBootstrap::MythicBeasts(inner) => inner.validate(errors), + DnsServerBootstrap::Namecheap(inner) => inner.validate(errors), + DnsServerBootstrap::NameDotCom(inner) => inner.validate(errors), + DnsServerBootstrap::NameSilo(inner) => inner.validate(errors), + DnsServerBootstrap::Netcup(inner) => inner.validate(errors), + DnsServerBootstrap::Netlify(inner) => inner.validate(errors), + DnsServerBootstrap::Nifcloud(inner) => inner.validate(errors), + DnsServerBootstrap::Ns1(inner) => inner.validate(errors), + DnsServerBootstrap::OracleCloud(inner) => inner.validate(errors), + DnsServerBootstrap::Plesk(inner) => inner.validate(errors), + DnsServerBootstrap::Safedns(inner) => inner.validate(errors), + DnsServerBootstrap::Scaleway(inner) => inner.validate(errors), + DnsServerBootstrap::TencentCloud(inner) => inner.validate(errors), + DnsServerBootstrap::Transip(inner) => inner.validate(errors), + DnsServerBootstrap::UltraDns(inner) => inner.validate(errors), + DnsServerBootstrap::Vercel(inner) => inner.validate(errors), + DnsServerBootstrap::Volcengine(inner) => inner.validate(errors), + DnsServerBootstrap::Vultr(inner) => inner.validate(errors), + DnsServerBootstrap::WebSupport(inner) => inner.validate(errors), + DnsServerBootstrap::YandexCloud(inner) => inner.validate(errors), } } } @@ -10523,9 +12435,8 @@ impl Pickle for DnsServerBootstrap { 1u16.pickle(out); inner.pickle(out); } - DnsServerBootstrap::Sig0(inner) => { + DnsServerBootstrap::Deprecated1 => { 2u16.pickle(out); - inner.pickle(out); } DnsServerBootstrap::Cloudflare(inner) => { 3u16.pickle(out); @@ -10567,6 +12478,238 @@ impl Pickle for DnsServerBootstrap { 12u16.pickle(out); inner.pickle(out); } + DnsServerBootstrap::Alidns(inner) => { + 13u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::ArvanCloud(inner) => { + 14u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Autodns(inner) => { + 15u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::AzureDns(inner) => { + 16u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::BaiduCloud(inner) => { + 17u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::BluecatV2(inner) => { + 18u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::ClouDns(inner) => { + 19u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Constellix(inner) => { + 20u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Cpanel(inner) => { + 21u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Ddnss(inner) => { + 22u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::DnsMadeEasy(inner) => { + 23u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Domeneshop(inner) => { + 24u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Dreamhost(inner) => { + 25u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::DuckDns(inner) => { + 26u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Dynu(inner) => { + 27u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::EasyDns(inner) => { + 28u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::EdgeDns(inner) => { + 29u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Exoscale(inner) => { + 30u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::FreeMyIp(inner) => { + 31u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::GandiV5(inner) => { + 32u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Gcore(inner) => { + 33u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Glesys(inner) => { + 34u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Godaddy(inner) => { + 35u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Hetzner(inner) => { + 36u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::HostingDe(inner) => { + 37u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Hostinger(inner) => { + 38u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::HuaweiCloud(inner) => { + 39u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Hurricane(inner) => { + 40u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::IbmCloud(inner) => { + 41u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Infoblox(inner) => { + 42u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Infomaniak(inner) => { + 43u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Inwx(inner) => { + 44u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Ionos(inner) => { + 45u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Ipv64(inner) => { + 46u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Joker(inner) => { + 47u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Lightsail(inner) => { + 48u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Linode(inner) => { + 49u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::LuaDns(inner) => { + 50u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::MythicBeasts(inner) => { + 51u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Namecheap(inner) => { + 52u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::NameDotCom(inner) => { + 53u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::NameSilo(inner) => { + 54u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Netcup(inner) => { + 55u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Netlify(inner) => { + 56u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Nifcloud(inner) => { + 57u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Ns1(inner) => { + 58u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::OracleCloud(inner) => { + 59u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Plesk(inner) => { + 60u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Safedns(inner) => { + 61u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Scaleway(inner) => { + 62u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::TencentCloud(inner) => { + 63u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Transip(inner) => { + 64u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::UltraDns(inner) => { + 65u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Vercel(inner) => { + 66u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Volcengine(inner) => { + 67u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::Vultr(inner) => { + 68u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::WebSupport(inner) => { + 69u16.pickle(out); + inner.pickle(out); + } + DnsServerBootstrap::YandexCloud(inner) => { + 70u16.pickle(out); + inner.pickle(out); + } } } @@ -10574,7 +12717,7 @@ impl Pickle for DnsServerBootstrap { match u16::unpickle(stream)? { 0 => Some(DnsServerBootstrap::Manual), 1 => Pickle::unpickle(stream).map(DnsServerBootstrap::Tsig), - 2 => Pickle::unpickle(stream).map(DnsServerBootstrap::Sig0), + 2 => Some(DnsServerBootstrap::Deprecated1), 3 => Pickle::unpickle(stream).map(DnsServerBootstrap::Cloudflare), 4 => Pickle::unpickle(stream).map(DnsServerBootstrap::DigitalOcean), 5 => Pickle::unpickle(stream).map(DnsServerBootstrap::DeSEC), @@ -10585,6 +12728,64 @@ impl Pickle for DnsServerBootstrap { 10 => Pickle::unpickle(stream).map(DnsServerBootstrap::Spaceship), 11 => Pickle::unpickle(stream).map(DnsServerBootstrap::Route53), 12 => Pickle::unpickle(stream).map(DnsServerBootstrap::GoogleCloudDns), + 13 => Pickle::unpickle(stream).map(DnsServerBootstrap::Alidns), + 14 => Pickle::unpickle(stream).map(DnsServerBootstrap::ArvanCloud), + 15 => Pickle::unpickle(stream).map(DnsServerBootstrap::Autodns), + 16 => Pickle::unpickle(stream).map(DnsServerBootstrap::AzureDns), + 17 => Pickle::unpickle(stream).map(DnsServerBootstrap::BaiduCloud), + 18 => Pickle::unpickle(stream).map(DnsServerBootstrap::BluecatV2), + 19 => Pickle::unpickle(stream).map(DnsServerBootstrap::ClouDns), + 20 => Pickle::unpickle(stream).map(DnsServerBootstrap::Constellix), + 21 => Pickle::unpickle(stream).map(DnsServerBootstrap::Cpanel), + 22 => Pickle::unpickle(stream).map(DnsServerBootstrap::Ddnss), + 23 => Pickle::unpickle(stream).map(DnsServerBootstrap::DnsMadeEasy), + 24 => Pickle::unpickle(stream).map(DnsServerBootstrap::Domeneshop), + 25 => Pickle::unpickle(stream).map(DnsServerBootstrap::Dreamhost), + 26 => Pickle::unpickle(stream).map(DnsServerBootstrap::DuckDns), + 27 => Pickle::unpickle(stream).map(DnsServerBootstrap::Dynu), + 28 => Pickle::unpickle(stream).map(DnsServerBootstrap::EasyDns), + 29 => Pickle::unpickle(stream).map(DnsServerBootstrap::EdgeDns), + 30 => Pickle::unpickle(stream).map(DnsServerBootstrap::Exoscale), + 31 => Pickle::unpickle(stream).map(DnsServerBootstrap::FreeMyIp), + 32 => Pickle::unpickle(stream).map(DnsServerBootstrap::GandiV5), + 33 => Pickle::unpickle(stream).map(DnsServerBootstrap::Gcore), + 34 => Pickle::unpickle(stream).map(DnsServerBootstrap::Glesys), + 35 => Pickle::unpickle(stream).map(DnsServerBootstrap::Godaddy), + 36 => Pickle::unpickle(stream).map(DnsServerBootstrap::Hetzner), + 37 => Pickle::unpickle(stream).map(DnsServerBootstrap::HostingDe), + 38 => Pickle::unpickle(stream).map(DnsServerBootstrap::Hostinger), + 39 => Pickle::unpickle(stream).map(DnsServerBootstrap::HuaweiCloud), + 40 => Pickle::unpickle(stream).map(DnsServerBootstrap::Hurricane), + 41 => Pickle::unpickle(stream).map(DnsServerBootstrap::IbmCloud), + 42 => Pickle::unpickle(stream).map(DnsServerBootstrap::Infoblox), + 43 => Pickle::unpickle(stream).map(DnsServerBootstrap::Infomaniak), + 44 => Pickle::unpickle(stream).map(DnsServerBootstrap::Inwx), + 45 => Pickle::unpickle(stream).map(DnsServerBootstrap::Ionos), + 46 => Pickle::unpickle(stream).map(DnsServerBootstrap::Ipv64), + 47 => Pickle::unpickle(stream).map(DnsServerBootstrap::Joker), + 48 => Pickle::unpickle(stream).map(DnsServerBootstrap::Lightsail), + 49 => Pickle::unpickle(stream).map(DnsServerBootstrap::Linode), + 50 => Pickle::unpickle(stream).map(DnsServerBootstrap::LuaDns), + 51 => Pickle::unpickle(stream).map(DnsServerBootstrap::MythicBeasts), + 52 => Pickle::unpickle(stream).map(DnsServerBootstrap::Namecheap), + 53 => Pickle::unpickle(stream).map(DnsServerBootstrap::NameDotCom), + 54 => Pickle::unpickle(stream).map(DnsServerBootstrap::NameSilo), + 55 => Pickle::unpickle(stream).map(DnsServerBootstrap::Netcup), + 56 => Pickle::unpickle(stream).map(DnsServerBootstrap::Netlify), + 57 => Pickle::unpickle(stream).map(DnsServerBootstrap::Nifcloud), + 58 => Pickle::unpickle(stream).map(DnsServerBootstrap::Ns1), + 59 => Pickle::unpickle(stream).map(DnsServerBootstrap::OracleCloud), + 60 => Pickle::unpickle(stream).map(DnsServerBootstrap::Plesk), + 61 => Pickle::unpickle(stream).map(DnsServerBootstrap::Safedns), + 62 => Pickle::unpickle(stream).map(DnsServerBootstrap::Scaleway), + 63 => Pickle::unpickle(stream).map(DnsServerBootstrap::TencentCloud), + 64 => Pickle::unpickle(stream).map(DnsServerBootstrap::Transip), + 65 => Pickle::unpickle(stream).map(DnsServerBootstrap::UltraDns), + 66 => Pickle::unpickle(stream).map(DnsServerBootstrap::Vercel), + 67 => Pickle::unpickle(stream).map(DnsServerBootstrap::Volcengine), + 68 => Pickle::unpickle(stream).map(DnsServerBootstrap::Vultr), + 69 => Pickle::unpickle(stream).map(DnsServerBootstrap::WebSupport), + 70 => Pickle::unpickle(stream).map(DnsServerBootstrap::YandexCloud), _ => None, } } @@ -10605,12 +12806,10 @@ impl IntoValue for DnsServerBootstrap { .insert_unchecked(Property::Type, JmapValue::Str("Tsig".into())); obj } - DnsServerBootstrap::Sig0(obj) => { - let mut obj = obj.into_value(); - obj.as_object_mut() - .unwrap() - .insert_unchecked(Property::Type, JmapValue::Str("Sig0".into())); - obj + DnsServerBootstrap::Deprecated1 => { + let mut obj = jmap_tools::Map::new(); + obj.insert_unchecked(Property::Type, JmapValue::Str("Deprecated1".into())); + JmapValue::Object(obj) } DnsServerBootstrap::Cloudflare(obj) => { let mut obj = obj.into_value(); @@ -10682,6 +12881,412 @@ impl IntoValue for DnsServerBootstrap { .insert_unchecked(Property::Type, JmapValue::Str("GoogleCloudDns".into())); obj } + DnsServerBootstrap::Alidns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Alidns".into())); + obj + } + DnsServerBootstrap::ArvanCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("ArvanCloud".into())); + obj + } + DnsServerBootstrap::Autodns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Autodns".into())); + obj + } + DnsServerBootstrap::AzureDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("AzureDns".into())); + obj + } + DnsServerBootstrap::BaiduCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("BaiduCloud".into())); + obj + } + DnsServerBootstrap::BluecatV2(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("BluecatV2".into())); + obj + } + DnsServerBootstrap::ClouDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("ClouDns".into())); + obj + } + DnsServerBootstrap::Constellix(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Constellix".into())); + obj + } + DnsServerBootstrap::Cpanel(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Cpanel".into())); + obj + } + DnsServerBootstrap::Ddnss(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ddnss".into())); + obj + } + DnsServerBootstrap::DnsMadeEasy(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("DnsMadeEasy".into())); + obj + } + DnsServerBootstrap::Domeneshop(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Domeneshop".into())); + obj + } + DnsServerBootstrap::Dreamhost(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Dreamhost".into())); + obj + } + DnsServerBootstrap::DuckDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("DuckDns".into())); + obj + } + DnsServerBootstrap::Dynu(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Dynu".into())); + obj + } + DnsServerBootstrap::EasyDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("EasyDns".into())); + obj + } + DnsServerBootstrap::EdgeDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("EdgeDns".into())); + obj + } + DnsServerBootstrap::Exoscale(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Exoscale".into())); + obj + } + DnsServerBootstrap::FreeMyIp(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("FreeMyIp".into())); + obj + } + DnsServerBootstrap::GandiV5(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("GandiV5".into())); + obj + } + DnsServerBootstrap::Gcore(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Gcore".into())); + obj + } + DnsServerBootstrap::Glesys(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Glesys".into())); + obj + } + DnsServerBootstrap::Godaddy(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Godaddy".into())); + obj + } + DnsServerBootstrap::Hetzner(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hetzner".into())); + obj + } + DnsServerBootstrap::HostingDe(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("HostingDe".into())); + obj + } + DnsServerBootstrap::Hostinger(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hostinger".into())); + obj + } + DnsServerBootstrap::HuaweiCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("HuaweiCloud".into())); + obj + } + DnsServerBootstrap::Hurricane(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Hurricane".into())); + obj + } + DnsServerBootstrap::IbmCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("IbmCloud".into())); + obj + } + DnsServerBootstrap::Infoblox(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Infoblox".into())); + obj + } + DnsServerBootstrap::Infomaniak(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Infomaniak".into())); + obj + } + DnsServerBootstrap::Inwx(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Inwx".into())); + obj + } + DnsServerBootstrap::Ionos(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ionos".into())); + obj + } + DnsServerBootstrap::Ipv64(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ipv64".into())); + obj + } + DnsServerBootstrap::Joker(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Joker".into())); + obj + } + DnsServerBootstrap::Lightsail(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Lightsail".into())); + obj + } + DnsServerBootstrap::Linode(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Linode".into())); + obj + } + DnsServerBootstrap::LuaDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("LuaDns".into())); + obj + } + DnsServerBootstrap::MythicBeasts(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("MythicBeasts".into())); + obj + } + DnsServerBootstrap::Namecheap(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Namecheap".into())); + obj + } + DnsServerBootstrap::NameDotCom(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("NameDotCom".into())); + obj + } + DnsServerBootstrap::NameSilo(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("NameSilo".into())); + obj + } + DnsServerBootstrap::Netcup(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Netcup".into())); + obj + } + DnsServerBootstrap::Netlify(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Netlify".into())); + obj + } + DnsServerBootstrap::Nifcloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Nifcloud".into())); + obj + } + DnsServerBootstrap::Ns1(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Ns1".into())); + obj + } + DnsServerBootstrap::OracleCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("OracleCloud".into())); + obj + } + DnsServerBootstrap::Plesk(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Plesk".into())); + obj + } + DnsServerBootstrap::Safedns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Safedns".into())); + obj + } + DnsServerBootstrap::Scaleway(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Scaleway".into())); + obj + } + DnsServerBootstrap::TencentCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("TencentCloud".into())); + obj + } + DnsServerBootstrap::Transip(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Transip".into())); + obj + } + DnsServerBootstrap::UltraDns(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("UltraDns".into())); + obj + } + DnsServerBootstrap::Vercel(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Vercel".into())); + obj + } + DnsServerBootstrap::Volcengine(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Volcengine".into())); + obj + } + DnsServerBootstrap::Vultr(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("Vultr".into())); + obj + } + DnsServerBootstrap::WebSupport(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("WebSupport".into())); + obj + } + DnsServerBootstrap::YandexCloud(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("YandexCloud".into())); + obj + } } } } @@ -10698,9 +13303,7 @@ impl RegistryJsonPatch for DnsServerBootstrap { DnsServerBootstrapType::Tsig => { *self = DnsServerBootstrap::Tsig(Default::default()) } - DnsServerBootstrapType::Sig0 => { - *self = DnsServerBootstrap::Sig0(Default::default()) - } + DnsServerBootstrapType::Deprecated1 => *self = DnsServerBootstrap::Deprecated1, DnsServerBootstrapType::Cloudflare => { *self = DnsServerBootstrap::Cloudflare(Default::default()) } @@ -10729,12 +13332,184 @@ impl RegistryJsonPatch for DnsServerBootstrap { DnsServerBootstrapType::GoogleCloudDns => { *self = DnsServerBootstrap::GoogleCloudDns(Default::default()) } + DnsServerBootstrapType::Alidns => { + *self = DnsServerBootstrap::Alidns(Default::default()) + } + DnsServerBootstrapType::ArvanCloud => { + *self = DnsServerBootstrap::ArvanCloud(Default::default()) + } + DnsServerBootstrapType::Autodns => { + *self = DnsServerBootstrap::Autodns(Default::default()) + } + DnsServerBootstrapType::AzureDns => { + *self = DnsServerBootstrap::AzureDns(Default::default()) + } + DnsServerBootstrapType::BaiduCloud => { + *self = DnsServerBootstrap::BaiduCloud(Default::default()) + } + DnsServerBootstrapType::BluecatV2 => { + *self = DnsServerBootstrap::BluecatV2(Default::default()) + } + DnsServerBootstrapType::ClouDns => { + *self = DnsServerBootstrap::ClouDns(Default::default()) + } + DnsServerBootstrapType::Constellix => { + *self = DnsServerBootstrap::Constellix(Default::default()) + } + DnsServerBootstrapType::Cpanel => { + *self = DnsServerBootstrap::Cpanel(Default::default()) + } + DnsServerBootstrapType::Ddnss => { + *self = DnsServerBootstrap::Ddnss(Default::default()) + } + DnsServerBootstrapType::DnsMadeEasy => { + *self = DnsServerBootstrap::DnsMadeEasy(Default::default()) + } + DnsServerBootstrapType::Domeneshop => { + *self = DnsServerBootstrap::Domeneshop(Default::default()) + } + DnsServerBootstrapType::Dreamhost => { + *self = DnsServerBootstrap::Dreamhost(Default::default()) + } + DnsServerBootstrapType::DuckDns => { + *self = DnsServerBootstrap::DuckDns(Default::default()) + } + DnsServerBootstrapType::Dynu => { + *self = DnsServerBootstrap::Dynu(Default::default()) + } + DnsServerBootstrapType::EasyDns => { + *self = DnsServerBootstrap::EasyDns(Default::default()) + } + DnsServerBootstrapType::EdgeDns => { + *self = DnsServerBootstrap::EdgeDns(Default::default()) + } + DnsServerBootstrapType::Exoscale => { + *self = DnsServerBootstrap::Exoscale(Default::default()) + } + DnsServerBootstrapType::FreeMyIp => { + *self = DnsServerBootstrap::FreeMyIp(Default::default()) + } + DnsServerBootstrapType::GandiV5 => { + *self = DnsServerBootstrap::GandiV5(Default::default()) + } + DnsServerBootstrapType::Gcore => { + *self = DnsServerBootstrap::Gcore(Default::default()) + } + DnsServerBootstrapType::Glesys => { + *self = DnsServerBootstrap::Glesys(Default::default()) + } + DnsServerBootstrapType::Godaddy => { + *self = DnsServerBootstrap::Godaddy(Default::default()) + } + DnsServerBootstrapType::Hetzner => { + *self = DnsServerBootstrap::Hetzner(Default::default()) + } + DnsServerBootstrapType::HostingDe => { + *self = DnsServerBootstrap::HostingDe(Default::default()) + } + DnsServerBootstrapType::Hostinger => { + *self = DnsServerBootstrap::Hostinger(Default::default()) + } + DnsServerBootstrapType::HuaweiCloud => { + *self = DnsServerBootstrap::HuaweiCloud(Default::default()) + } + DnsServerBootstrapType::Hurricane => { + *self = DnsServerBootstrap::Hurricane(Default::default()) + } + DnsServerBootstrapType::IbmCloud => { + *self = DnsServerBootstrap::IbmCloud(Default::default()) + } + DnsServerBootstrapType::Infoblox => { + *self = DnsServerBootstrap::Infoblox(Default::default()) + } + DnsServerBootstrapType::Infomaniak => { + *self = DnsServerBootstrap::Infomaniak(Default::default()) + } + DnsServerBootstrapType::Inwx => { + *self = DnsServerBootstrap::Inwx(Default::default()) + } + DnsServerBootstrapType::Ionos => { + *self = DnsServerBootstrap::Ionos(Default::default()) + } + DnsServerBootstrapType::Ipv64 => { + *self = DnsServerBootstrap::Ipv64(Default::default()) + } + DnsServerBootstrapType::Joker => { + *self = DnsServerBootstrap::Joker(Default::default()) + } + DnsServerBootstrapType::Lightsail => { + *self = DnsServerBootstrap::Lightsail(Default::default()) + } + DnsServerBootstrapType::Linode => { + *self = DnsServerBootstrap::Linode(Default::default()) + } + DnsServerBootstrapType::LuaDns => { + *self = DnsServerBootstrap::LuaDns(Default::default()) + } + DnsServerBootstrapType::MythicBeasts => { + *self = DnsServerBootstrap::MythicBeasts(Default::default()) + } + DnsServerBootstrapType::Namecheap => { + *self = DnsServerBootstrap::Namecheap(Default::default()) + } + DnsServerBootstrapType::NameDotCom => { + *self = DnsServerBootstrap::NameDotCom(Default::default()) + } + DnsServerBootstrapType::NameSilo => { + *self = DnsServerBootstrap::NameSilo(Default::default()) + } + DnsServerBootstrapType::Netcup => { + *self = DnsServerBootstrap::Netcup(Default::default()) + } + DnsServerBootstrapType::Netlify => { + *self = DnsServerBootstrap::Netlify(Default::default()) + } + DnsServerBootstrapType::Nifcloud => { + *self = DnsServerBootstrap::Nifcloud(Default::default()) + } + DnsServerBootstrapType::Ns1 => *self = DnsServerBootstrap::Ns1(Default::default()), + DnsServerBootstrapType::OracleCloud => { + *self = DnsServerBootstrap::OracleCloud(Default::default()) + } + DnsServerBootstrapType::Plesk => { + *self = DnsServerBootstrap::Plesk(Default::default()) + } + DnsServerBootstrapType::Safedns => { + *self = DnsServerBootstrap::Safedns(Default::default()) + } + DnsServerBootstrapType::Scaleway => { + *self = DnsServerBootstrap::Scaleway(Default::default()) + } + DnsServerBootstrapType::TencentCloud => { + *self = DnsServerBootstrap::TencentCloud(Default::default()) + } + DnsServerBootstrapType::Transip => { + *self = DnsServerBootstrap::Transip(Default::default()) + } + DnsServerBootstrapType::UltraDns => { + *self = DnsServerBootstrap::UltraDns(Default::default()) + } + DnsServerBootstrapType::Vercel => { + *self = DnsServerBootstrap::Vercel(Default::default()) + } + DnsServerBootstrapType::Volcengine => { + *self = DnsServerBootstrap::Volcengine(Default::default()) + } + DnsServerBootstrapType::Vultr => { + *self = DnsServerBootstrap::Vultr(Default::default()) + } + DnsServerBootstrapType::WebSupport => { + *self = DnsServerBootstrap::WebSupport(Default::default()) + } + DnsServerBootstrapType::YandexCloud => { + *self = DnsServerBootstrap::YandexCloud(Default::default()) + } } } match self { DnsServerBootstrap::Manual => pointer.assert_eof(), DnsServerBootstrap::Tsig(inner) => inner.patch(pointer, value), - DnsServerBootstrap::Sig0(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Deprecated1 => pointer.assert_eof(), DnsServerBootstrap::Cloudflare(inner) => inner.patch(pointer, value), DnsServerBootstrap::DigitalOcean(inner) => inner.patch(pointer, value), DnsServerBootstrap::DeSEC(inner) => inner.patch(pointer, value), @@ -10745,6 +13520,64 @@ impl RegistryJsonPatch for DnsServerBootstrap { DnsServerBootstrap::Spaceship(inner) => inner.patch(pointer, value), DnsServerBootstrap::Route53(inner) => inner.patch(pointer, value), DnsServerBootstrap::GoogleCloudDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Alidns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::ArvanCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Autodns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::AzureDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::BaiduCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::BluecatV2(inner) => inner.patch(pointer, value), + DnsServerBootstrap::ClouDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Constellix(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Cpanel(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Ddnss(inner) => inner.patch(pointer, value), + DnsServerBootstrap::DnsMadeEasy(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Domeneshop(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Dreamhost(inner) => inner.patch(pointer, value), + DnsServerBootstrap::DuckDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Dynu(inner) => inner.patch(pointer, value), + DnsServerBootstrap::EasyDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::EdgeDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Exoscale(inner) => inner.patch(pointer, value), + DnsServerBootstrap::FreeMyIp(inner) => inner.patch(pointer, value), + DnsServerBootstrap::GandiV5(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Gcore(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Glesys(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Godaddy(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Hetzner(inner) => inner.patch(pointer, value), + DnsServerBootstrap::HostingDe(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Hostinger(inner) => inner.patch(pointer, value), + DnsServerBootstrap::HuaweiCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Hurricane(inner) => inner.patch(pointer, value), + DnsServerBootstrap::IbmCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Infoblox(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Infomaniak(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Inwx(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Ionos(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Ipv64(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Joker(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Lightsail(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Linode(inner) => inner.patch(pointer, value), + DnsServerBootstrap::LuaDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::MythicBeasts(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Namecheap(inner) => inner.patch(pointer, value), + DnsServerBootstrap::NameDotCom(inner) => inner.patch(pointer, value), + DnsServerBootstrap::NameSilo(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Netcup(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Netlify(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Nifcloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Ns1(inner) => inner.patch(pointer, value), + DnsServerBootstrap::OracleCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Plesk(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Safedns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Scaleway(inner) => inner.patch(pointer, value), + DnsServerBootstrap::TencentCloud(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Transip(inner) => inner.patch(pointer, value), + DnsServerBootstrap::UltraDns(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Vercel(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Volcengine(inner) => inner.patch(pointer, value), + DnsServerBootstrap::Vultr(inner) => inner.patch(pointer, value), + DnsServerBootstrap::WebSupport(inner) => inner.patch(pointer, value), + DnsServerBootstrap::YandexCloud(inner) => inner.patch(pointer, value), } } } @@ -10754,7 +13587,7 @@ impl DnsServerBootstrap { match self { DnsServerBootstrap::Manual => DnsServerBootstrapType::Manual, DnsServerBootstrap::Tsig(_) => DnsServerBootstrapType::Tsig, - DnsServerBootstrap::Sig0(_) => DnsServerBootstrapType::Sig0, + DnsServerBootstrap::Deprecated1 => DnsServerBootstrapType::Deprecated1, DnsServerBootstrap::Cloudflare(_) => DnsServerBootstrapType::Cloudflare, DnsServerBootstrap::DigitalOcean(_) => DnsServerBootstrapType::DigitalOcean, DnsServerBootstrap::DeSEC(_) => DnsServerBootstrapType::DeSEC, @@ -10765,6 +13598,206 @@ impl DnsServerBootstrap { DnsServerBootstrap::Spaceship(_) => DnsServerBootstrapType::Spaceship, DnsServerBootstrap::Route53(_) => DnsServerBootstrapType::Route53, DnsServerBootstrap::GoogleCloudDns(_) => DnsServerBootstrapType::GoogleCloudDns, + DnsServerBootstrap::Alidns(_) => DnsServerBootstrapType::Alidns, + DnsServerBootstrap::ArvanCloud(_) => DnsServerBootstrapType::ArvanCloud, + DnsServerBootstrap::Autodns(_) => DnsServerBootstrapType::Autodns, + DnsServerBootstrap::AzureDns(_) => DnsServerBootstrapType::AzureDns, + DnsServerBootstrap::BaiduCloud(_) => DnsServerBootstrapType::BaiduCloud, + DnsServerBootstrap::BluecatV2(_) => DnsServerBootstrapType::BluecatV2, + DnsServerBootstrap::ClouDns(_) => DnsServerBootstrapType::ClouDns, + DnsServerBootstrap::Constellix(_) => DnsServerBootstrapType::Constellix, + DnsServerBootstrap::Cpanel(_) => DnsServerBootstrapType::Cpanel, + DnsServerBootstrap::Ddnss(_) => DnsServerBootstrapType::Ddnss, + DnsServerBootstrap::DnsMadeEasy(_) => DnsServerBootstrapType::DnsMadeEasy, + DnsServerBootstrap::Domeneshop(_) => DnsServerBootstrapType::Domeneshop, + DnsServerBootstrap::Dreamhost(_) => DnsServerBootstrapType::Dreamhost, + DnsServerBootstrap::DuckDns(_) => DnsServerBootstrapType::DuckDns, + DnsServerBootstrap::Dynu(_) => DnsServerBootstrapType::Dynu, + DnsServerBootstrap::EasyDns(_) => DnsServerBootstrapType::EasyDns, + DnsServerBootstrap::EdgeDns(_) => DnsServerBootstrapType::EdgeDns, + DnsServerBootstrap::Exoscale(_) => DnsServerBootstrapType::Exoscale, + DnsServerBootstrap::FreeMyIp(_) => DnsServerBootstrapType::FreeMyIp, + DnsServerBootstrap::GandiV5(_) => DnsServerBootstrapType::GandiV5, + DnsServerBootstrap::Gcore(_) => DnsServerBootstrapType::Gcore, + DnsServerBootstrap::Glesys(_) => DnsServerBootstrapType::Glesys, + DnsServerBootstrap::Godaddy(_) => DnsServerBootstrapType::Godaddy, + DnsServerBootstrap::Hetzner(_) => DnsServerBootstrapType::Hetzner, + DnsServerBootstrap::HostingDe(_) => DnsServerBootstrapType::HostingDe, + DnsServerBootstrap::Hostinger(_) => DnsServerBootstrapType::Hostinger, + DnsServerBootstrap::HuaweiCloud(_) => DnsServerBootstrapType::HuaweiCloud, + DnsServerBootstrap::Hurricane(_) => DnsServerBootstrapType::Hurricane, + DnsServerBootstrap::IbmCloud(_) => DnsServerBootstrapType::IbmCloud, + DnsServerBootstrap::Infoblox(_) => DnsServerBootstrapType::Infoblox, + DnsServerBootstrap::Infomaniak(_) => DnsServerBootstrapType::Infomaniak, + DnsServerBootstrap::Inwx(_) => DnsServerBootstrapType::Inwx, + DnsServerBootstrap::Ionos(_) => DnsServerBootstrapType::Ionos, + DnsServerBootstrap::Ipv64(_) => DnsServerBootstrapType::Ipv64, + DnsServerBootstrap::Joker(_) => DnsServerBootstrapType::Joker, + DnsServerBootstrap::Lightsail(_) => DnsServerBootstrapType::Lightsail, + DnsServerBootstrap::Linode(_) => DnsServerBootstrapType::Linode, + DnsServerBootstrap::LuaDns(_) => DnsServerBootstrapType::LuaDns, + DnsServerBootstrap::MythicBeasts(_) => DnsServerBootstrapType::MythicBeasts, + DnsServerBootstrap::Namecheap(_) => DnsServerBootstrapType::Namecheap, + DnsServerBootstrap::NameDotCom(_) => DnsServerBootstrapType::NameDotCom, + DnsServerBootstrap::NameSilo(_) => DnsServerBootstrapType::NameSilo, + DnsServerBootstrap::Netcup(_) => DnsServerBootstrapType::Netcup, + DnsServerBootstrap::Netlify(_) => DnsServerBootstrapType::Netlify, + DnsServerBootstrap::Nifcloud(_) => DnsServerBootstrapType::Nifcloud, + DnsServerBootstrap::Ns1(_) => DnsServerBootstrapType::Ns1, + DnsServerBootstrap::OracleCloud(_) => DnsServerBootstrapType::OracleCloud, + DnsServerBootstrap::Plesk(_) => DnsServerBootstrapType::Plesk, + DnsServerBootstrap::Safedns(_) => DnsServerBootstrapType::Safedns, + DnsServerBootstrap::Scaleway(_) => DnsServerBootstrapType::Scaleway, + DnsServerBootstrap::TencentCloud(_) => DnsServerBootstrapType::TencentCloud, + DnsServerBootstrap::Transip(_) => DnsServerBootstrapType::Transip, + DnsServerBootstrap::UltraDns(_) => DnsServerBootstrapType::UltraDns, + DnsServerBootstrap::Vercel(_) => DnsServerBootstrapType::Vercel, + DnsServerBootstrap::Volcengine(_) => DnsServerBootstrapType::Volcengine, + DnsServerBootstrap::Vultr(_) => DnsServerBootstrapType::Vultr, + DnsServerBootstrap::WebSupport(_) => DnsServerBootstrapType::WebSupport, + DnsServerBootstrap::YandexCloud(_) => DnsServerBootstrapType::YandexCloud, + } + } +} + +impl DnsServerClouDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + if let Some(value) = &self.auth_id { + if value.is_empty() { + errors.push(ValidationError::required(Property::AuthId)); + } + } + if let Some(value) = &self.sub_auth_id { + if value.is_empty() { + errors.push(ValidationError::required(Property::SubAuthId)); + } + } + let value = &self.password; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerClouDns { + fn pickle(&self, out: &mut Vec) { + self.auth_id.pickle(out); + self.sub_auth_id.pickle(out); + self.password.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.auth_id = Pickle::unpickle(stream)?; + this.sub_auth_id = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerClouDns { + fn default() -> Self { + Self { + auth_id: Default::default(), + sub_auth_id: Default::default(), + password: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerClouDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::AuthId, self.auth_id.into_value()); + map.insert_unchecked(Property::SubAuthId, self.sub_auth_id.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerClouDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AuthId) => self + .auth_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SubAuthId) => self + .sub_auth_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), } } } @@ -10890,11 +13923,6 @@ impl RegistryJsonPropertyPatch for DnsServerCloud { impl DnsServerCloudflare { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); - if let Some(value) = &self.email { - if value.is_empty() { - errors.push(ValidationError::required(Property::Email)); - } - } let value = &self.secret; value.validate(errors); let value = &self.description; @@ -10919,7 +13947,6 @@ impl DnsServerCloudflare { impl Pickle for DnsServerCloudflare { fn pickle(&self, out: &mut Vec) { - self.email.pickle(out); self.secret.pickle(out); self.description.pickle(out); self.member_tenant_id.pickle(out); @@ -10932,7 +13959,9 @@ impl Pickle for DnsServerCloudflare { fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { let mut this = Self::default(); - this.email = Pickle::unpickle(stream)?; + if stream.version() < 1 { + let _: Option = Pickle::unpickle(stream)?; + } this.secret = Pickle::unpickle(stream)?; this.description = Pickle::unpickle(stream)?; this.member_tenant_id = Pickle::unpickle(stream)?; @@ -10948,7 +13977,6 @@ impl Pickle for DnsServerCloudflare { impl Default for DnsServerCloudflare { fn default() -> Self { Self { - email: Default::default(), secret: Default::default(), description: Default::default(), member_tenant_id: Default::default(), @@ -10963,8 +13991,7 @@ impl Default for DnsServerCloudflare { impl IntoValue for DnsServerCloudflare { fn into_value(self) -> JmapValue<'static> { - let mut map = jmap_tools::Map::with_capacity(11); - map.insert_unchecked(Property::Email, self.email.into_value()); + let mut map = jmap_tools::Map::with_capacity(10); map.insert_unchecked(Property::Secret, self.secret.into_value()); map.insert_unchecked(Property::Description, self.description.into_value()); map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); @@ -10993,8 +14020,404 @@ impl RegistryJsonPropertyPatch for DnsServerCloudflare { value: JmapValue<'x>, ) -> PatchResult<'x> { match pointer.next_property() { - Some(Property::Email) => self - .email + Some(property @ Property::Email) => Ok(MaybeUnpatched::Unpatched { property, value }), + Some(Property::Secret) => self.secret.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerConstellix { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.secret_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerConstellix { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.secret_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerConstellix { + fn default() -> Self { + Self { + api_key: Default::default(), + secret_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerConstellix { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerConstellix { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self + .api_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerCpanel { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.base_url; + if value.is_empty() { + errors.push(ValidationError::required(Property::BaseUrl)); + } + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.token; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerCpanel { + fn pickle(&self, out: &mut Vec) { + self.base_url.pickle(out); + self.username.pickle(out); + self.token.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.base_url = Pickle::unpickle(stream)?; + this.username = Pickle::unpickle(stream)?; + this.token = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerCpanel { + fn default() -> Self { + Self { + base_url: Default::default(), + username: Default::default(), + token: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerCpanel { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::BaseUrl, self.base_url.into_value()); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Token, self.token.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerCpanel { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::BaseUrl) => self + .base_url + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Token) => self.token.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerDnsMadeEasy { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerDnsMadeEasy { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.secret.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerDnsMadeEasy { + fn default() -> Self { + Self { + api_key: Default::default(), + secret: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerDnsMadeEasy { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerDnsMadeEasy { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self + .api_key .patch(pointer.with_validators(&[StringValidator::Trim]), value), Some(Property::Secret) => self.secret.patch(pointer, value), Some(Property::Description) => self @@ -11026,8 +14449,6 @@ impl DnsServerDnsimple { if value.is_empty() { errors.push(ValidationError::required(Property::AccountIdentifier)); } - let value = &self.secret; - value.validate(errors); let value = &self.description; if value.is_empty() { errors.push(ValidationError::required(Property::Description)); @@ -11052,7 +14473,6 @@ impl Pickle for DnsServerDnsimple { fn pickle(&self, out: &mut Vec) { self.auth_token.pickle(out); self.account_identifier.pickle(out); - self.secret.pickle(out); self.description.pickle(out); self.member_tenant_id.pickle(out); self.timeout.pickle(out); @@ -11066,7 +14486,9 @@ impl Pickle for DnsServerDnsimple { let mut this = Self::default(); this.auth_token = Pickle::unpickle(stream)?; this.account_identifier = Pickle::unpickle(stream)?; - this.secret = Pickle::unpickle(stream)?; + if stream.version() < 1 { + let _: SecretKey = Pickle::unpickle(stream)?; + } this.description = Pickle::unpickle(stream)?; this.member_tenant_id = Pickle::unpickle(stream)?; this.timeout = Pickle::unpickle(stream)?; @@ -11083,7 +14505,6 @@ impl Default for DnsServerDnsimple { Self { auth_token: Default::default(), account_identifier: Default::default(), - secret: Default::default(), description: Default::default(), member_tenant_id: Default::default(), timeout: Duration::from_millis(30000), @@ -11097,13 +14518,12 @@ impl Default for DnsServerDnsimple { impl IntoValue for DnsServerDnsimple { fn into_value(self) -> JmapValue<'static> { - let mut map = jmap_tools::Map::with_capacity(12); + let mut map = jmap_tools::Map::with_capacity(11); map.insert_unchecked(Property::AuthToken, self.auth_token.into_value()); map.insert_unchecked( Property::AccountIdentifier, self.account_identifier.into_value(), ); - map.insert_unchecked(Property::Secret, self.secret.into_value()); map.insert_unchecked(Property::Description, self.description.into_value()); map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); map.insert_unchecked(Property::Timeout, self.timeout.into_value()); @@ -11135,6 +14555,813 @@ impl RegistryJsonPropertyPatch for DnsServerDnsimple { Some(Property::AccountIdentifier) => self .account_identifier .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(property @ Property::Secret) => Ok(MaybeUnpatched::Unpatched { property, value }), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerDomeneshop { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.auth_token; + if value.is_empty() { + errors.push(ValidationError::required(Property::AuthToken)); + } + let value = &self.secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerDomeneshop { + fn pickle(&self, out: &mut Vec) { + self.auth_token.pickle(out); + self.secret.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.auth_token = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerDomeneshop { + fn default() -> Self { + Self { + auth_token: Default::default(), + secret: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerDomeneshop { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::AuthToken, self.auth_token.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerDomeneshop { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AuthToken) => self + .auth_token + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Secret) => self.secret.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerEasyDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.token; + if value.is_empty() { + errors.push(ValidationError::required(Property::Token)); + } + let value = &self.key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerEasyDns { + fn pickle(&self, out: &mut Vec) { + self.token.pickle(out); + self.key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.token = Pickle::unpickle(stream)?; + this.key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerEasyDns { + fn default() -> Self { + Self { + token: Default::default(), + key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerEasyDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Token, self.token.into_value()); + map.insert_unchecked(Property::Key, self.key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerEasyDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Token) => self + .token + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Key) => self.key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerEdgeDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.host; + if value.is_empty() { + errors.push(ValidationError::required(Property::Host)); + } + let value = &self.client_token; + if value.is_empty() { + errors.push(ValidationError::required(Property::ClientToken)); + } + let value = &self.client_secret; + value.validate(errors); + let value = &self.access_token; + value.validate(errors); + if let Some(value) = &self.account_switch_key { + if value.is_empty() { + errors.push(ValidationError::required(Property::AccountSwitchKey)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerEdgeDns { + fn pickle(&self, out: &mut Vec) { + self.host.pickle(out); + self.client_token.pickle(out); + self.client_secret.pickle(out); + self.access_token.pickle(out); + self.account_switch_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.host = Pickle::unpickle(stream)?; + this.client_token = Pickle::unpickle(stream)?; + this.client_secret = Pickle::unpickle(stream)?; + this.access_token = Pickle::unpickle(stream)?; + this.account_switch_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerEdgeDns { + fn default() -> Self { + Self { + host: Default::default(), + client_token: Default::default(), + client_secret: Default::default(), + access_token: Default::default(), + account_switch_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerEdgeDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(14); + map.insert_unchecked(Property::Host, self.host.into_value()); + map.insert_unchecked(Property::ClientToken, self.client_token.into_value()); + map.insert_unchecked(Property::ClientSecret, self.client_secret.into_value()); + map.insert_unchecked(Property::AccessToken, self.access_token.into_value()); + map.insert_unchecked( + Property::AccountSwitchKey, + self.account_switch_key.into_value(), + ); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerEdgeDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Host) => self + .host + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ClientToken) => self + .client_token + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ClientSecret) => self.client_secret.patch(pointer, value), + Some(Property::AccessToken) => self.access_token.patch(pointer, value), + Some(Property::AccountSwitchKey) => self + .account_switch_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerExoscale { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerExoscale { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.secret.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerExoscale { + fn default() -> Self { + Self { + api_key: Default::default(), + secret: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerExoscale { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerExoscale { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self + .api_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Secret) => self.secret.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerGlesys { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_user; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiUser)); + } + let value = &self.api_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerGlesys { + fn pickle(&self, out: &mut Vec) { + self.api_user.pickle(out); + self.api_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_user = Pickle::unpickle(stream)?; + this.api_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerGlesys { + fn default() -> Self { + Self { + api_user: Default::default(), + api_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerGlesys { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiUser, self.api_user.into_value()); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerGlesys { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiUser) => self + .api_user + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerGodaddy { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerGodaddy { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.secret.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerGodaddy { + fn default() -> Self { + Self { + api_key: Default::default(), + secret: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerGodaddy { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerGodaddy { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self + .api_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), Some(Property::Secret) => self.secret.patch(pointer, value), Some(Property::Description) => self .description @@ -11322,6 +15549,1990 @@ impl RegistryJsonPropertyPatch for DnsServerGoogleCloudDns { } } +impl DnsServerHuaweiCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKey)); + } + let value = &self.secret_key; + value.validate(errors); + let value = &self.region; + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerHuaweiCloud { + fn pickle(&self, out: &mut Vec) { + self.access_key.pickle(out); + self.secret_key.pickle(out); + self.region.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerHuaweiCloud { + fn default() -> Self { + Self { + access_key: Default::default(), + secret_key: Default::default(), + region: "ap-southeast-1".to_string(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerHuaweiCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::AccessKey, self.access_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerHuaweiCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKey) => self + .access_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerHurricane { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.credentials; + for value in value.values() { + value.validate(errors); + } + if value.len() < 1 { + errors.push(ValidationError::min_items(Property::Credentials, 1)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerHurricane { + fn pickle(&self, out: &mut Vec) { + self.credentials.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.credentials = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerHurricane { + fn default() -> Self { + Self { + credentials: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerHurricane { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(10); + map.insert_unchecked(Property::Credentials, self.credentials.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerHurricane { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Credentials) => self.credentials.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerIbmCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.api_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerIbmCloud { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.api_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.api_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerIbmCloud { + fn default() -> Self { + Self { + username: Default::default(), + api_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerIbmCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerIbmCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerInfoblox { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.host; + if value.is_empty() { + errors.push(ValidationError::required(Property::Host)); + } + if let Some(value) = &self.port { + if value.is_empty() { + errors.push(ValidationError::required(Property::Port)); + } + } + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + if let Some(value) = &self.wapi_version { + if value.is_empty() { + errors.push(ValidationError::required(Property::WapiVersion)); + } + } + if let Some(value) = &self.dns_view { + if value.is_empty() { + errors.push(ValidationError::required(Property::DnsView)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerInfoblox { + fn pickle(&self, out: &mut Vec) { + self.host.pickle(out); + self.port.pickle(out); + self.username.pickle(out); + self.password.pickle(out); + self.wapi_version.pickle(out); + self.dns_view.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.host = Pickle::unpickle(stream)?; + this.port = Pickle::unpickle(stream)?; + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.wapi_version = Pickle::unpickle(stream)?; + this.dns_view = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerInfoblox { + fn default() -> Self { + Self { + host: Default::default(), + port: Default::default(), + username: Default::default(), + password: Default::default(), + wapi_version: Default::default(), + dns_view: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerInfoblox { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(15); + map.insert_unchecked(Property::Host, self.host.into_value()); + map.insert_unchecked(Property::Port, self.port.into_value()); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::WapiVersion, self.wapi_version.into_value()); + map.insert_unchecked(Property::DnsView, self.dns_view.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerInfoblox { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Host) => self + .host + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Port) => self + .port + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::WapiVersion) => self + .wapi_version + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::DnsView) => self + .dns_view + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerInwx { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + let value = &self.shared_secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerInwx { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.password.pickle(out); + self.shared_secret.pickle(out); + self.sandbox.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.shared_secret = Pickle::unpickle(stream)?; + this.sandbox = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerInwx { + fn default() -> Self { + Self { + username: Default::default(), + password: Default::default(), + shared_secret: Default::default(), + sandbox: false, + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerInwx { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(13); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::SharedSecret, self.shared_secret.into_value()); + map.insert_unchecked(Property::Sandbox, self.sandbox.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerInwx { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::SharedSecret) => self.shared_secret.patch(pointer, value), + Some(Property::Sandbox) => self.sandbox.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerJoker { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.auth; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerJoker { + fn pickle(&self, out: &mut Vec) { + self.auth.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.auth = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerJoker { + fn default() -> Self { + Self { + auth: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerJoker { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(10); + map.insert_unchecked(Property::Auth, self.auth.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerJoker { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Auth) => self.auth.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerLightsail { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKeyId)); + } + let value = &self.secret_access_key; + value.validate(errors); + let value = &self.session_token; + value.validate(errors); + if let Some(value) = &self.region { + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + } + if let Some(value) = &self.domain { + if value.is_empty() { + errors.push(ValidationError::required(Property::Domain)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerLightsail { + fn pickle(&self, out: &mut Vec) { + self.access_key_id.pickle(out); + self.secret_access_key.pickle(out); + self.session_token.pickle(out); + self.region.pickle(out); + self.domain.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key_id = Pickle::unpickle(stream)?; + this.secret_access_key = Pickle::unpickle(stream)?; + this.session_token = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.domain = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerLightsail { + fn default() -> Self { + Self { + access_key_id: Default::default(), + secret_access_key: Default::default(), + session_token: Default::default(), + region: Default::default(), + domain: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerLightsail { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(14); + map.insert_unchecked(Property::AccessKeyId, self.access_key_id.into_value()); + map.insert_unchecked( + Property::SecretAccessKey, + self.secret_access_key.into_value(), + ); + map.insert_unchecked(Property::SessionToken, self.session_token.into_value()); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked(Property::Domain, self.domain.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerLightsail { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKeyId) => self + .access_key_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretAccessKey) => self.secret_access_key.patch(pointer, value), + Some(Property::SessionToken) => self.session_token.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Domain) => self + .domain + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerLuaDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.auth_token; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerLuaDns { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.auth_token.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.auth_token = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerLuaDns { + fn default() -> Self { + Self { + username: Default::default(), + auth_token: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerLuaDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::AuthToken, self.auth_token.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerLuaDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::AuthToken) => self.auth_token.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerMythicBeasts { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerMythicBeasts { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.password.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerMythicBeasts { + fn default() -> Self { + Self { + username: Default::default(), + password: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerMythicBeasts { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerMythicBeasts { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerNameDotCom { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.auth_token; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerNameDotCom { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.auth_token.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.auth_token = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerNameDotCom { + fn default() -> Self { + Self { + username: Default::default(), + auth_token: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerNameDotCom { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::AuthToken, self.auth_token.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerNameDotCom { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::AuthToken) => self.auth_token.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerNamecheap { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_user; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiUser)); + } + let value = &self.api_key; + value.validate(errors); + let value = &self.client_ip; + if value.is_empty() { + errors.push(ValidationError::required(Property::ClientIp)); + } + if let Some(value) = &self.username { + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerNamecheap { + fn pickle(&self, out: &mut Vec) { + self.api_user.pickle(out); + self.api_key.pickle(out); + self.client_ip.pickle(out); + self.username.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_user = Pickle::unpickle(stream)?; + this.api_key = Pickle::unpickle(stream)?; + this.client_ip = Pickle::unpickle(stream)?; + this.username = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerNamecheap { + fn default() -> Self { + Self { + api_user: Default::default(), + api_key: Default::default(), + client_ip: Default::default(), + username: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerNamecheap { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(13); + map.insert_unchecked(Property::ApiUser, self.api_user.into_value()); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::ClientIp, self.client_ip.into_value()); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerNamecheap { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiUser) => self + .api_user + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::ClientIp) => self + .client_ip + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerNetcup { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.customer_number; + if value.is_empty() { + errors.push(ValidationError::required(Property::CustomerNumber)); + } + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.password; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerNetcup { + fn pickle(&self, out: &mut Vec) { + self.customer_number.pickle(out); + self.api_key.pickle(out); + self.password.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.customer_number = Pickle::unpickle(stream)?; + this.api_key = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerNetcup { + fn default() -> Self { + Self { + customer_number: Default::default(), + api_key: Default::default(), + password: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerNetcup { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::CustomerNumber, self.customer_number.into_value()); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerNetcup { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::CustomerNumber) => self + .customer_number + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ApiKey) => self + .api_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerNifcloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKey)); + } + let value = &self.secret_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerNifcloud { + fn pickle(&self, out: &mut Vec) { + self.access_key.pickle(out); + self.secret_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerNifcloud { + fn default() -> Self { + Self { + access_key: Default::default(), + secret_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerNifcloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::AccessKey, self.access_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerNifcloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKey) => self + .access_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerOracleCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.tenancy_ocid; + if value.is_empty() { + errors.push(ValidationError::required(Property::TenancyOcid)); + } + let value = &self.user_ocid; + if value.is_empty() { + errors.push(ValidationError::required(Property::UserOcid)); + } + let value = &self.fingerprint; + if value.is_empty() { + errors.push(ValidationError::required(Property::Fingerprint)); + } + let value = &self.private_key_pem; + value.validate(errors); + let value = &self.private_key_password; + value.validate(errors); + let value = &self.region; + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + let value = &self.compartment_ocid; + if value.is_empty() { + errors.push(ValidationError::required(Property::CompartmentOcid)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerOracleCloud { + fn pickle(&self, out: &mut Vec) { + self.tenancy_ocid.pickle(out); + self.user_ocid.pickle(out); + self.fingerprint.pickle(out); + self.private_key_pem.pickle(out); + self.private_key_password.pickle(out); + self.region.pickle(out); + self.compartment_ocid.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.tenancy_ocid = Pickle::unpickle(stream)?; + this.user_ocid = Pickle::unpickle(stream)?; + this.fingerprint = Pickle::unpickle(stream)?; + this.private_key_pem = Pickle::unpickle(stream)?; + this.private_key_password = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.compartment_ocid = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerOracleCloud { + fn default() -> Self { + Self { + tenancy_ocid: Default::default(), + user_ocid: Default::default(), + fingerprint: Default::default(), + private_key_pem: Default::default(), + private_key_password: Default::default(), + region: Default::default(), + compartment_ocid: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerOracleCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(16); + map.insert_unchecked(Property::TenancyOcid, self.tenancy_ocid.into_value()); + map.insert_unchecked(Property::UserOcid, self.user_ocid.into_value()); + map.insert_unchecked(Property::Fingerprint, self.fingerprint.into_value()); + map.insert_unchecked(Property::PrivateKeyPem, self.private_key_pem.into_value()); + map.insert_unchecked( + Property::PrivateKeyPassword, + self.private_key_password.into_value(), + ); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked( + Property::CompartmentOcid, + self.compartment_ocid.into_value(), + ); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerOracleCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::TenancyOcid) => self + .tenancy_ocid + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::UserOcid) => self + .user_ocid + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Fingerprint) => self + .fingerprint + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::PrivateKeyPem) => self.private_key_pem.patch(pointer, value), + Some(Property::PrivateKeyPassword) => self.private_key_password.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::CompartmentOcid) => self + .compartment_ocid + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl DnsServerOvh { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); @@ -11466,6 +17677,135 @@ impl RegistryJsonPropertyPatch for DnsServerOvh { } } +impl DnsServerPlesk { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.base_url; + if value.is_empty() { + errors.push(ValidationError::required(Property::BaseUrl)); + } + let value = &self.api_key; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerPlesk { + fn pickle(&self, out: &mut Vec) { + self.base_url.pickle(out); + self.api_key.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.base_url = Pickle::unpickle(stream)?; + this.api_key = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerPlesk { + fn default() -> Self { + Self { + base_url: Default::default(), + api_key: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerPlesk { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::BaseUrl, self.base_url.into_value()); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerPlesk { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::BaseUrl) => self + .base_url + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl DnsServerPorkbun { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); @@ -11475,8 +17815,6 @@ impl DnsServerPorkbun { } let value = &self.secret_api_key; value.validate(errors); - let value = &self.secret; - value.validate(errors); let value = &self.description; if value.is_empty() { errors.push(ValidationError::required(Property::Description)); @@ -11501,7 +17839,6 @@ impl Pickle for DnsServerPorkbun { fn pickle(&self, out: &mut Vec) { self.api_key.pickle(out); self.secret_api_key.pickle(out); - self.secret.pickle(out); self.description.pickle(out); self.member_tenant_id.pickle(out); self.timeout.pickle(out); @@ -11515,7 +17852,9 @@ impl Pickle for DnsServerPorkbun { let mut this = Self::default(); this.api_key = Pickle::unpickle(stream)?; this.secret_api_key = Pickle::unpickle(stream)?; - this.secret = Pickle::unpickle(stream)?; + if stream.version() < 1 { + let _: SecretKey = Pickle::unpickle(stream)?; + } this.description = Pickle::unpickle(stream)?; this.member_tenant_id = Pickle::unpickle(stream)?; this.timeout = Pickle::unpickle(stream)?; @@ -11532,7 +17871,6 @@ impl Default for DnsServerPorkbun { Self { api_key: Default::default(), secret_api_key: Default::default(), - secret: Default::default(), description: Default::default(), member_tenant_id: Default::default(), timeout: Duration::from_millis(30000), @@ -11546,10 +17884,9 @@ impl Default for DnsServerPorkbun { impl IntoValue for DnsServerPorkbun { fn into_value(self) -> JmapValue<'static> { - let mut map = jmap_tools::Map::with_capacity(12); + let mut map = jmap_tools::Map::with_capacity(11); map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); map.insert_unchecked(Property::SecretApiKey, self.secret_api_key.into_value()); - map.insert_unchecked(Property::Secret, self.secret.into_value()); map.insert_unchecked(Property::Description, self.description.into_value()); map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); map.insert_unchecked(Property::Timeout, self.timeout.into_value()); @@ -11581,7 +17918,7 @@ impl RegistryJsonPropertyPatch for DnsServerPorkbun { .api_key .patch(pointer.with_validators(&[StringValidator::Trim]), value), Some(Property::SecretApiKey) => self.secret_api_key.patch(pointer, value), - Some(Property::Secret) => self.secret.patch(pointer, value), + Some(property @ Property::Secret) => Ok(MaybeUnpatched::Unpatched { property, value }), Some(Property::Description) => self .description .patch(pointer.with_validators(&[StringValidator::Trim]), value), @@ -11772,179 +18109,6 @@ impl RegistryJsonPropertyPatch for DnsServerRoute53 { } } -impl DnsServerSig0 { - fn validate(&self, errors: &mut Vec) -> bool { - let neb = errors.len(); - let value = &self.host; - if !value.is_valid() { - errors.push(ValidationError::invalid(Property::Host, value)); - } - let value = &self.port; - if *value > 65535 { - errors.push(ValidationError::max_value(Property::Port, 65535)); - } - if *value < 1 { - errors.push(ValidationError::min_value(Property::Port, 1)); - } - let value = &self.public_key; - if value.is_empty() { - errors.push(ValidationError::required(Property::PublicKey)); - } - let value = &self.key; - value.validate(errors); - let value = &self.signer_name; - if value.is_empty() { - errors.push(ValidationError::required(Property::SignerName)); - } - let value = &self.description; - if value.is_empty() { - errors.push(ValidationError::required(Property::Description)); - } - if let Some(value) = &self.member_tenant_id { - if !value.is_valid() { - errors.push(ValidationError::required(Property::MemberTenantId)); - } - } - errors.len() == neb - } - - fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { - i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); - if let Some(value) = &self.member_tenant_id { - i.search(Property::MemberTenantId, value); - } - } -} - -impl Pickle for DnsServerSig0 { - fn pickle(&self, out: &mut Vec) { - self.host.pickle(out); - self.port.pickle(out); - self.public_key.pickle(out); - self.key.pickle(out); - self.signer_name.pickle(out); - self.protocol.pickle(out); - self.sig0_algorithm.pickle(out); - self.description.pickle(out); - self.member_tenant_id.pickle(out); - self.timeout.pickle(out); - self.ttl.pickle(out); - self.polling_interval.pickle(out); - self.propagation_timeout.pickle(out); - self.propagation_delay.pickle(out); - } - - fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { - let mut this = Self::default(); - this.host = Pickle::unpickle(stream)?; - this.port = Pickle::unpickle(stream)?; - this.public_key = Pickle::unpickle(stream)?; - this.key = Pickle::unpickle(stream)?; - this.signer_name = Pickle::unpickle(stream)?; - this.protocol = Pickle::unpickle(stream)?; - this.sig0_algorithm = Pickle::unpickle(stream)?; - this.description = Pickle::unpickle(stream)?; - this.member_tenant_id = Pickle::unpickle(stream)?; - this.timeout = Pickle::unpickle(stream)?; - this.ttl = Pickle::unpickle(stream)?; - this.polling_interval = Pickle::unpickle(stream)?; - this.propagation_timeout = Pickle::unpickle(stream)?; - this.propagation_delay = Pickle::unpickle(stream)?; - Some(this) - } -} - -impl Default for DnsServerSig0 { - fn default() -> Self { - Self { - host: Default::default(), - port: 53u64, - public_key: Default::default(), - key: Default::default(), - signer_name: Default::default(), - protocol: IpProtocol::Udp, - sig0_algorithm: Sig0Algorithm::Ed25519, - description: Default::default(), - member_tenant_id: Default::default(), - timeout: Duration::from_millis(30000), - ttl: Duration::from_millis(300000), - polling_interval: Duration::from_millis(15000), - propagation_timeout: Duration::from_millis(60000), - propagation_delay: Default::default(), - } - } -} - -impl IntoValue for DnsServerSig0 { - fn into_value(self) -> JmapValue<'static> { - let mut map = jmap_tools::Map::with_capacity(16); - map.insert_unchecked(Property::Host, self.host.into_value()); - map.insert_unchecked(Property::Port, self.port.into_value()); - map.insert_unchecked(Property::PublicKey, self.public_key.into_value()); - map.insert_unchecked(Property::Key, self.key.into_value()); - map.insert_unchecked(Property::SignerName, self.signer_name.into_value()); - map.insert_unchecked(Property::Protocol, self.protocol.into_value()); - map.insert_unchecked(Property::Sig0Algorithm, self.sig0_algorithm.into_value()); - map.insert_unchecked(Property::Description, self.description.into_value()); - map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); - map.insert_unchecked(Property::Timeout, self.timeout.into_value()); - map.insert_unchecked(Property::Ttl, self.ttl.into_value()); - map.insert_unchecked( - Property::PollingInterval, - self.polling_interval.into_value(), - ); - map.insert_unchecked( - Property::PropagationTimeout, - self.propagation_timeout.into_value(), - ); - map.insert_unchecked( - Property::PropagationDelay, - self.propagation_delay.into_value(), - ); - JmapValue::Object(map) - } -} - -impl RegistryJsonPropertyPatch for DnsServerSig0 { - fn patch_property<'x>( - &mut self, - mut pointer: JsonPointerPatch<'_>, - value: JmapValue<'x>, - ) -> PatchResult<'x> { - match pointer.next_property() { - Some(Property::Host) => self - .host - .patch(pointer.with_validators(&[StringValidator::Trim]), value), - Some(Property::Port) => self.port.patch(pointer, value), - Some(Property::PublicKey) => self - .public_key - .patch(pointer.with_validators(&[StringValidator::Trim]), value), - Some(Property::Key) => self.key.patch(pointer, value), - Some(Property::SignerName) => self - .signer_name - .patch(pointer.with_validators(&[StringValidator::Trim]), value), - Some(Property::Protocol) => self.protocol.patch(pointer, value), - Some(Property::Sig0Algorithm) => self.sig0_algorithm.patch(pointer, value), - Some(Property::Description) => self - .description - .patch(pointer.with_validators(&[StringValidator::Trim]), value), - Some(Property::MemberTenantId) => self - .member_tenant_id - .patch(pointer.assert_can_set_tenant()?, value), - Some(Property::Timeout) => self.timeout.patch(pointer, value), - Some(Property::Ttl) => self.ttl.patch(pointer, value), - Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), - Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), - Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), - Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { - property: Property::Type, - value, - }), - _ => Err(PatchError::new(pointer, "Invalid property")), - } - } -} - impl DnsServerSpaceship { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); @@ -12074,6 +18238,283 @@ impl RegistryJsonPropertyPatch for DnsServerSpaceship { } } +impl DnsServerTencentCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.secret_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::SecretId)); + } + let value = &self.secret_key; + value.validate(errors); + if let Some(value) = &self.region { + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + } + let value = &self.session_token; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerTencentCloud { + fn pickle(&self, out: &mut Vec) { + self.secret_id.pickle(out); + self.secret_key.pickle(out); + self.region.pickle(out); + self.session_token.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.secret_id = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.session_token = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerTencentCloud { + fn default() -> Self { + Self { + secret_id: Default::default(), + secret_key: Default::default(), + region: Default::default(), + session_token: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerTencentCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(13); + map.insert_unchecked(Property::SecretId, self.secret_id.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked(Property::SessionToken, self.session_token.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerTencentCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::SecretId) => self + .secret_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SessionToken) => self.session_token.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerTransip { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.private_key_pem; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerTransip { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.private_key_pem.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.private_key_pem = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerTransip { + fn default() -> Self { + Self { + username: Default::default(), + private_key_pem: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerTransip { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::PrivateKeyPem, self.private_key_pem.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerTransip { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::PrivateKeyPem) => self.private_key_pem.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl DnsServerTsig { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); @@ -12236,6 +18677,700 @@ impl RegistryJsonPropertyPatch for DnsServerTsig { } } +impl DnsServerUltraDns { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + if let Some(value) = &self.endpoint { + if value.is_empty() { + errors.push(ValidationError::required(Property::Endpoint)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerUltraDns { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.password.pickle(out); + self.endpoint.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + this.endpoint = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerUltraDns { + fn default() -> Self { + Self { + username: Default::default(), + password: Default::default(), + endpoint: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerUltraDns { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(12); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + map.insert_unchecked(Property::Endpoint, self.endpoint.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerUltraDns { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Endpoint) => self + .endpoint + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerVercel { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.auth_token; + value.validate(errors); + if let Some(value) = &self.team_id { + if value.is_empty() { + errors.push(ValidationError::required(Property::TeamId)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerVercel { + fn pickle(&self, out: &mut Vec) { + self.auth_token.pickle(out); + self.team_id.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.auth_token = Pickle::unpickle(stream)?; + this.team_id = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerVercel { + fn default() -> Self { + Self { + auth_token: Default::default(), + team_id: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerVercel { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::AuthToken, self.auth_token.into_value()); + map.insert_unchecked(Property::TeamId, self.team_id.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerVercel { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AuthToken) => self.auth_token.patch(pointer, value), + Some(Property::TeamId) => self + .team_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerVolcengine { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.access_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::AccessKey)); + } + let value = &self.secret_key; + value.validate(errors); + if let Some(value) = &self.region { + if value.is_empty() { + errors.push(ValidationError::required(Property::Region)); + } + } + if let Some(value) = &self.host { + if value.is_empty() { + errors.push(ValidationError::required(Property::Host)); + } + } + if let Some(value) = &self.scheme { + if value.is_empty() { + errors.push(ValidationError::required(Property::Scheme)); + } + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerVolcengine { + fn pickle(&self, out: &mut Vec) { + self.access_key.pickle(out); + self.secret_key.pickle(out); + self.region.pickle(out); + self.host.pickle(out); + self.scheme.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.access_key = Pickle::unpickle(stream)?; + this.secret_key = Pickle::unpickle(stream)?; + this.region = Pickle::unpickle(stream)?; + this.host = Pickle::unpickle(stream)?; + this.scheme = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerVolcengine { + fn default() -> Self { + Self { + access_key: Default::default(), + secret_key: Default::default(), + region: Default::default(), + host: Default::default(), + scheme: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerVolcengine { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(14); + map.insert_unchecked(Property::AccessKey, self.access_key.into_value()); + map.insert_unchecked(Property::SecretKey, self.secret_key.into_value()); + map.insert_unchecked(Property::Region, self.region.into_value()); + map.insert_unchecked(Property::Host, self.host.into_value()); + map.insert_unchecked(Property::Scheme, self.scheme.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerVolcengine { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::AccessKey) => self + .access_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::SecretKey) => self.secret_key.patch(pointer, value), + Some(Property::Region) => self + .region + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Host) => self + .host + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Scheme) => self + .scheme + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerWebSupport { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + if value.is_empty() { + errors.push(ValidationError::required(Property::ApiKey)); + } + let value = &self.secret; + value.validate(errors); + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerWebSupport { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.secret.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerWebSupport { + fn default() -> Self { + Self { + api_key: Default::default(), + secret: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerWebSupport { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerWebSupport { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self + .api_key + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Secret) => self.secret.patch(pointer, value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl DnsServerYandexCloud { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + value.validate(errors); + let value = &self.folder_id; + if value.is_empty() { + errors.push(ValidationError::required(Property::FolderId)); + } + let value = &self.description; + if value.is_empty() { + errors.push(ValidationError::required(Property::Description)); + } + if let Some(value) = &self.member_tenant_id { + if !value.is_valid() { + errors.push(ValidationError::required(Property::MemberTenantId)); + } + } + errors.len() == neb + } + + fn index<'x>(&'x self, i: &mut IndexBuilder<'x>) { + i.foreign_key(ObjectType::Tenant, self.member_tenant_id, None); + if let Some(value) = &self.member_tenant_id { + i.search(Property::MemberTenantId, value); + } + } +} + +impl Pickle for DnsServerYandexCloud { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + self.folder_id.pickle(out); + self.description.pickle(out); + self.member_tenant_id.pickle(out); + self.timeout.pickle(out); + self.ttl.pickle(out); + self.polling_interval.pickle(out); + self.propagation_timeout.pickle(out); + self.propagation_delay.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + this.folder_id = Pickle::unpickle(stream)?; + this.description = Pickle::unpickle(stream)?; + this.member_tenant_id = Pickle::unpickle(stream)?; + this.timeout = Pickle::unpickle(stream)?; + this.ttl = Pickle::unpickle(stream)?; + this.polling_interval = Pickle::unpickle(stream)?; + this.propagation_timeout = Pickle::unpickle(stream)?; + this.propagation_delay = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for DnsServerYandexCloud { + fn default() -> Self { + Self { + api_key: Default::default(), + folder_id: Default::default(), + description: Default::default(), + member_tenant_id: Default::default(), + timeout: Duration::from_millis(30000), + ttl: Duration::from_millis(300000), + polling_interval: Duration::from_millis(15000), + propagation_timeout: Duration::from_millis(60000), + propagation_delay: Default::default(), + } + } +} + +impl IntoValue for DnsServerYandexCloud { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(11); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + map.insert_unchecked(Property::FolderId, self.folder_id.into_value()); + map.insert_unchecked(Property::Description, self.description.into_value()); + map.insert_unchecked(Property::MemberTenantId, self.member_tenant_id.into_value()); + map.insert_unchecked(Property::Timeout, self.timeout.into_value()); + map.insert_unchecked(Property::Ttl, self.ttl.into_value()); + map.insert_unchecked( + Property::PollingInterval, + self.polling_interval.into_value(), + ); + map.insert_unchecked( + Property::PropagationTimeout, + self.propagation_timeout.into_value(), + ); + map.insert_unchecked( + Property::PropagationDelay, + self.propagation_delay.into_value(), + ); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for DnsServerYandexCloud { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::FolderId) => self + .folder_id + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Description) => self + .description + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::MemberTenantId) => self + .member_tenant_id + .patch(pointer.assert_can_set_tenant()?, value), + Some(Property::Timeout) => self.timeout.patch(pointer, value), + Some(Property::Ttl) => self.ttl.patch(pointer, value), + Some(Property::PollingInterval) => self.polling_interval.patch(pointer, value), + Some(Property::PropagationTimeout) => self.propagation_timeout.patch(pointer, value), + Some(Property::PropagationDelay) => self.propagation_delay.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl ObjectImpl for Domain { const FLAGS: u64 = OBJ_FILTER_TENANT | OBJ_SEQ_ID; const VERSION: u8 = 0; @@ -14901,6 +22036,72 @@ impl HttpLookupFormat { } } +impl HurricaneCredential { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.zone; + if value.is_empty() { + errors.push(ValidationError::required(Property::Zone)); + } + let value = &self.secret; + value.validate(errors); + errors.len() == neb + } +} + +impl Pickle for HurricaneCredential { + fn pickle(&self, out: &mut Vec) { + self.zone.pickle(out); + self.secret.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.zone = Pickle::unpickle(stream)?; + this.secret = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for HurricaneCredential { + fn default() -> Self { + Self { + zone: Default::default(), + secret: Default::default(), + } + } +} + +impl IntoValue for HurricaneCredential { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(4); + map.insert_unchecked(Property::Zone, self.zone.into_value()); + map.insert_unchecked(Property::Secret, self.secret.into_value()); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for HurricaneCredential { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Zone) => self.zone.patch( + pointer.with_validators(&[StringValidator::Domain, StringValidator::Trim]), + value, + ), + Some(Property::Secret) => self.secret.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl ObjectImpl for Imap { const FLAGS: u64 = OBJ_SINGLETON; const VERSION: u8 = 0; @@ -15570,6 +22771,214 @@ impl RegistryJsonPropertyPatch for Jmap { } } +impl JokerAuth { + fn validate(&self, errors: &mut Vec) -> bool { + match self { + JokerAuth::ApiKey(inner) => inner.validate(errors), + JokerAuth::UsernamePassword(inner) => inner.validate(errors), + } + } +} + +impl Default for JokerAuth { + fn default() -> Self { + JokerAuth::ApiKey(Default::default()) + } +} + +impl Pickle for JokerAuth { + fn pickle(&self, out: &mut Vec) { + match self { + JokerAuth::ApiKey(inner) => { + 0u16.pickle(out); + inner.pickle(out); + } + JokerAuth::UsernamePassword(inner) => { + 1u16.pickle(out); + inner.pickle(out); + } + } + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + match u16::unpickle(stream)? { + 0 => Pickle::unpickle(stream).map(JokerAuth::ApiKey), + 1 => Pickle::unpickle(stream).map(JokerAuth::UsernamePassword), + _ => None, + } + } +} + +impl IntoValue for JokerAuth { + fn into_value(self) -> JmapValue<'static> { + match self { + JokerAuth::ApiKey(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("ApiKey".into())); + obj + } + JokerAuth::UsernamePassword(obj) => { + let mut obj = obj.into_value(); + obj.as_object_mut() + .unwrap() + .insert_unchecked(Property::Type, JmapValue::Str("UsernamePassword".into())); + obj + } + } + } +} + +impl RegistryJsonPatch for JokerAuth { + fn patch<'x>( + &mut self, + pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + if !pointer.has_next() { + match object_type(&pointer, &value)? { + JokerAuthType::ApiKey => *self = JokerAuth::ApiKey(Default::default()), + JokerAuthType::UsernamePassword => { + *self = JokerAuth::UsernamePassword(Default::default()) + } + } + } + match self { + JokerAuth::ApiKey(inner) => inner.patch(pointer, value), + JokerAuth::UsernamePassword(inner) => inner.patch(pointer, value), + } + } +} + +impl JokerAuth { + pub fn object_type(&self) -> JokerAuthType { + match self { + JokerAuth::ApiKey(_) => JokerAuthType::ApiKey, + JokerAuth::UsernamePassword(_) => JokerAuthType::UsernamePassword, + } + } +} + +impl JokerAuthApiKey { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.api_key; + value.validate(errors); + errors.len() == neb + } +} + +impl Pickle for JokerAuthApiKey { + fn pickle(&self, out: &mut Vec) { + self.api_key.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.api_key = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for JokerAuthApiKey { + fn default() -> Self { + Self { + api_key: Default::default(), + } + } +} + +impl IntoValue for JokerAuthApiKey { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(3); + map.insert_unchecked(Property::ApiKey, self.api_key.into_value()); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for JokerAuthApiKey { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::ApiKey) => self.api_key.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + +impl JokerAuthUsernamePassword { + fn validate(&self, errors: &mut Vec) -> bool { + let neb = errors.len(); + let value = &self.username; + if value.is_empty() { + errors.push(ValidationError::required(Property::Username)); + } + let value = &self.password; + value.validate(errors); + errors.len() == neb + } +} + +impl Pickle for JokerAuthUsernamePassword { + fn pickle(&self, out: &mut Vec) { + self.username.pickle(out); + self.password.pickle(out); + } + + fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { + let mut this = Self::default(); + this.username = Pickle::unpickle(stream)?; + this.password = Pickle::unpickle(stream)?; + Some(this) + } +} + +impl Default for JokerAuthUsernamePassword { + fn default() -> Self { + Self { + username: Default::default(), + password: Default::default(), + } + } +} + +impl IntoValue for JokerAuthUsernamePassword { + fn into_value(self) -> JmapValue<'static> { + let mut map = jmap_tools::Map::with_capacity(4); + map.insert_unchecked(Property::Username, self.username.into_value()); + map.insert_unchecked(Property::Password, self.password.into_value()); + JmapValue::Object(map) + } +} + +impl RegistryJsonPropertyPatch for JokerAuthUsernamePassword { + fn patch_property<'x>( + &mut self, + mut pointer: JsonPointerPatch<'_>, + value: JmapValue<'x>, + ) -> PatchResult<'x> { + match pointer.next_property() { + Some(Property::Username) => self + .username + .patch(pointer.with_validators(&[StringValidator::Trim]), value), + Some(Property::Password) => self.password.patch(pointer, value), + Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { + property: Property::Type, + value, + }), + _ => Err(PatchError::new(pointer, "Invalid property")), + } + } +} + impl KafkaCoordinator { fn validate(&self, errors: &mut Vec) -> bool { let neb = errors.len(); diff --git a/crates/services/Cargo.toml b/crates/services/Cargo.toml index 36777e77..9c0046fb 100644 --- a/crates/services/Cargo.toml +++ b/crates/services/Cargo.toml @@ -34,7 +34,7 @@ sha2 = "0.11" reqwest = { version = "0.13", default-features = false, features = ["rustls", "http2"]} base64 = "0.22" compact_str = "0.9.0" -dns-update = { version = "0.3" } +dns-update = { version = "0.4.0" } [dev-dependencies] diff --git a/resources/schema/schema.json.gz b/resources/schema/schema.json.gz index 32683f3a6b93f1bd0f3134fb89f5d143d06709f4..3a4b791efb1caaa58c496f67f9fab9bac3ad2086 100644 GIT binary patch literal 145720 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

nHfDePb5*1>YyWb#yqLJ?v{4jvjmxpRXY* z?Vg<-oa}G<689yh#EAx%>+go>>v#|PU)>-QoUb zl)&lLZp&aYcwB;69Gy-NHVv-1iu5`)tGi(2)3g8FIB>Hn-839JFq-;KWNlD96JYh} zhmBKUCCe5cV#(e_&)A>b`N8h&z~JkqX|j}XU;$b8kowyG!O_9^uW3C-`fI?M!>`oW z&JRv@k4Jxv#~S(?2g3Eg0v~yEv~k;15M3QWnWDOfAGlqu>#Oh!e?5DD^7H0TaBqto z!T5goDjNOm!EEo{rm?B#(9q?gD&iOW;XbU6u8ALczVE4JYG4uc(;c^2rH7?Rpz&de zB1Z`QriG|Vm%c|9q5{!;F!1#Kn~?*XNU?+8Xs)DSjK6aF^XdD|6JP-f_V!J^VzptA!v()R1{CUTNXwpYX+@ zP7mpTwAEauxpC}IO>H%18nbw^H~5@lAB3epa|;)skzmUK!?x8gE64vH4Jsr(0I-DMv0qbD#y6O)Nba@1{_4jZI6tphzDyC;|##^y$9 z3Kf?)lm5%kPYZIk_*9 z8Eo8@q4|8F-N-N2T@mibE*6hDG`r_-v)pa0(yvnDRg{IJ=lD0#t-36V1v${8gKRuu zSpcn$a>E98KG0#H8@96>H;cjE?gVz+5M_B_m-Xkv;~g};qVyl?;PnytBVea+@!D*kj6YY`%20$OB!Y%H%X{HbxoIA#?Ls^Vr*hJ$)Vw2S zqemJsq077id+a^ zn7}x>D6oOm@+int=?GNtSh@zxb>FuOMYXo#!ZtkSL{9KvnX%`)bb~yuiFOp^dzGH5TtqE z=kx0&3z|i~4n2s6m!{aUWRx#zh-LtEee`|#}i;KOG7@41cpd3Z*4_N;Am zEZNi>+=P^5ui838#k*~zg8(^sh(#3t+{6OcS+FOnmg4N0uSRC(8H&3z8xG@VXQnlE zY>g;psSJ1(P}&ZVjuXt&%v$@)s|kzwn%E(SXR(cm*@W{XwsL+ynFe;%j4eDDZRE&C zWZM4XCl$~azc$7UoI#G7f%72Sn1O#bkcTb3c@Ckaw;nQO>3udkPoy7^xMZTxDNNj8 z74$dK9+5-z1mit8K>Z2d_sUmVRr#y=C)P0@>Sn|g)$Dpn89F_Ag0vyQj%yAAgfA&J zZpE~bA%w~~bCS1LYouIVBy|7*<2Fd9rAC+Ninuo2TAN*EDo!gxq7RU}4mu3EV}gZC z!;x&29XJP8thGbwuK7l&SpOTVo!DRolW#+ z691}0yH9q4RPJMXE+Md#2XEqd8Vg7{OWvR#GH(GUOSwF(r_>&O)i2?}p??F2i&A(t zb}&MBX%bXgds%ngozPA=$*SZt!9hT}a4LXl*G=3}lTnH4H#lmlMh!bqP~s`qQ8S0@ zO=t6hooVlUXH6#9hr5KrcU_PLjGom?<4KT&Cm@okl;Bue~hdc}c zi)2DsSP&&~xRo&C1oICju#|}qW9%dD_|}xB)^5ewQZs3#-Z#Gq)3h$@71+XVsH zfWxo@sQ^K6`bvzPr>3ay$J+8;nm(zEfg~SJR=F|Y;K_-Jw zj*&{^s|^SNO(KTIsSTK6*U#Qcaf5OVU*ovJFQ9AN+{Nx3zL}6soUbuo%m7C~xW7bQ zts>(#N4nQdcnfX2q=l&ok-r4BRiRudu@~Cyz_Xb{c=av=!OTVv%w{d@NtbAvst;?< z2Dz|wclA6?-SKH2M(J?~JiXnMA$rV(5tN9V1!IRmUITpDhBA*28o zEt1G$?~>fTWZs`2+FQtv8f-4CI12x*Yw8pys}=)gM1xQf8yibm4%mvFl@mmb?)RDh zg)|e3;Hic_gskb+#3r+?5)v*Gjfn3u6rJkFci zf>Tj^qZsRm*b~ph$m_6mzVVaG@?V!WQNdV%xjXJ|)m&@>bZv)bI90(g zn1sNSvi8F{(bEy@Mu2GpNIT+^j^BSMl&w7CH1c5{gH{K-ju9{u3EMo4wt`&*zqTP& zw11T2*5L3BAaS}TRZ`ALwdK~(=eI!`XMO?dIMY)*d+*s1I`JT}d2O1}FyQut$ANb! zz`ZBnh9tM}!)7$?=vn+k4lwRWIVsaGgMjQjMc?M@FZg@J6cjwfv4L>*s$g@kNZ@gV z$JnA9sfw#(P^NwCi%%Azh)|bp5rr7HIWSdwgM0t?tzjpW*)#!xS2mQ95>SnV8s5Em z9h%t9sCX3Q7`~gvU_&kL@-;r_x*ZhbpMkjS{BUyx^4Qt8X3x-k_h30 z_(eQX_A#oSJ$n>ZDyB3K(&z+ryUHytsX5FqFO?;({Eic2#>pW#sCBT@(P`k|Lr?`w zM;FQewv5ltcJL=>Bvhsq8$L(IQBh-Y?-x1wd2^&<480e42+~XkLK@n6)y;(0Gn$-T zRVfEPs@+G7Rg|pmXN`P2 z#`cSNrB0ZM1e7{k$G}%o)*lxB(uMu-<>@^DuQS`vaM$d1kD?Pd{5n0eQ@FMf){DF= z{`kFnJ5a%W)|!W!!1KRBB8A$vf?2>AWa{ke!yu!!eG@9?7fEzk)Lk?JNRkdg9jhYD zp&dS|CgfEf1SM1f%vdk^O&EG+0OWz3>|WrXfhd_yL%td|5gik4S%+Su$XVZb^05K1 zttg$q_e4foitYfGlo=@_2KFiEB*!txl^WVz+I6kNcDNr&U0*aqT4xno&Vl!g1Ba2U zqe>@>mx5sxOV4JH!k#wXo;sMoGEvwuh3L7H>Jt;nJ8{cAz%hEv1XT1l#gLcxF}0gw zv+>T}qSFYUZ=<@YDSQz#cE~|}s`)RHh|r)JkE--%=&!K~IEwhpq}Og@UI{<&5i<(C z!P(zyN6STa;y&LJT=x3pX(galzMtG?yz8eLGxcSbJq>^P{n`HbFY|ySzKm`zgP%pu z_i^9U{*D{Jsr+3BKdZc6$9>s4y>9rj@_ilrvhsi(_hstp#{|hVYq2Qfu31IXENKv&Szm|28#7Z^MtHy=0mY?u<$4AN;6krB8b&}o70 z0|7AWxP%9V(#m7oI~8FfIAf}%Y*$jJc<}5}sD=sJaJxZYrc_L(-M9MH5PcmZ1({H0 z;m+-XTVx&^oT%DWa3~YFD`lzEax52>D%x$M^Bc)2&^z;m=k9;5WMg#09LH@wk)E?7 zO0MjX?0uvjucWvhN6%H4O=O*+B_k;Z++W~#$!Ueg0E^xG!sN~V+|cIyJZFi3kdarM zbsVdI%yxBsh#0D+h>Gk~6A+t-SxUh8CV*QsckXp>t@98n`IN~-gp3`A{eVb&=N{TY{G9{qV6i{hoL@6 z4L0~;h^9!lZ1dC?l~6e%NOlJs_cc9M_$@0oo@lwVFd8&MWwSx1QLwy11g&J)VE}=_ z#SR0qtM8@)udwZ z@>`-^_>qKaTHSI(+UNx9g?%(5?qh-b`97aqgI*$iN6vOLY%uDU)NQx9Cp`cnH>D53 z;9VI7Vbg8t!4Te;J_tiMW)y-Accuq`&HXb3#9!Q2V*#;4Zv-a5Mm^wYOf+X&_4Gf3 zvAS*gY&T4EgE5K!|K;Et>v<-*6-*QJ{g>ozZWN4m`ko09P& z6WJm(i1t*MH-H9(?ztxZu7$F5S^*I2h7Tr~*QC)1+D=WzmEOmPtB)dW zp2})Vhd`-+qJ1sNvP0qvp|P`UhqZh05hqRZTsFKq%fj`TQ+LGWwQIL{JvA+ZKci*H zZQs+fvpwN*pH9*H=PLD+hkX_t=hT>vZlm^;aRC|+`gl861u zWnYJbWs98Ebpd9fpr%M1e5Hq&uqr!cl_?}rwSQNmb0s^NHVQ6M^|&P6zU;0!)_RrgK9#cts-E5j;L+=amy_du4xF1UwqdkPNSS<&J-Tw4^b$xr8_hEY454Wb@v%tjfN z3!L%l23q_RBxc$CCZGYUG9MN3hYtl?OUipq^q^zYM?Q_f8c6R>P+Q?WV z)*}?=%iUBvUhrY{pHuKMV7hsSepJzq2!$LfeB$})md?B#JVxU{;af3}2TDJv|9@M% zr>u0b6+_j~2Vd-;t_N08MY81uZ0tmFj>>XnhUjkZ7**EQOx22hA+IjqW1iZasuAV{ ze6TQ<>X-d)Z)S6CI*sZrz51j%Z_GKSsHD>XJR_#{k) z5&!%`c6*IBAN8N0+|cC&>-v)U#1hw3LYEl`{~k);JWoMTPe5!ibPdao4(SV_SEZ4Yh_A z*QR8I>UNd=ULQ>^Dk=he6z^cf*EZb;12v<1NF>~7a68mX8fA@bP6qP@3G7Ge$-O?~ z$}Azxb*q8WpL89Ty$je=RS{w#2l4^z($eR(8Q4iaK`j{&M!$M~Kauuzzu{yUoq4I_ zDi#zeT3>HtN?+2Ku(8M8Q2|zYdc#rPK+g~6+l9*Ltc^u9BCJxWHQp`7Hif2u#}W;m zotIf(Iq}Z06Q3s(3PNu$nIRg3LFkwWD)vDjYO0!IRLKqmgdkjVHfmt+FYhpsr#|lH z)l=QIJk79jvM={P#;zdU-rW8;{_c_F{@RBo)i=jHH0i2uyGgprhb|aJ)Q-M0sR}gt z?Zd@<{6mwZv%It7>Z-22jDO_KKcggcy6f$N-<{zVh`}2GxJfo*G*f6Cn;U1Z*!AYE=>cNs{wjOO7NuSLwye;JPo+>>8)tT+$fvt8l`o_{08 zoKyVaGH?ZkgudeLi!rZ^^W7zZ_-j+0!t8|?0yzGr%Rfa?Ji$@Vx{;~%m2y}xD;3Xi zOdi9jfeXcs?6B*k;CN44C*VOy)82hR zZ4mlzsVxHZ?L5_S^SeDdK7aydAq=%RkST8S=4ULtj~mP!H7?t{)ou5jZ|FmD*-30pjqUV7$?y)vbj((?Q}7cvaDehI)*k#&u?JvoQTR@>nhiH zNKLIPlpTv}WFJZD0}SiCi7%&~cY&d@Sc%HcIJ&yP$K;iVZ%0%f+o(D_E^{-?ppLF0 z6>V7uD3XsXxDS5V7sQMs0sDI*!PvwVnUfBT_MQ=j>L8JKFBtpn5u^Ook}lAeRXlF>+k3s6|U3Cw3rQWZ!hu3Pe^w zccro{I>q(kGGGo@-31>wpwmeE#+4ijkgAE@MO-gKl6P6ETb|#U-5vD(*M=M`l6EhL zGw+r!woFqqxlV^63kD#OPgozkOC%+lGvb^LpUZKc$9dFfN7 zN9Aq}4vj?M6A;!1UPZFRJLWlgiu&g{nNdOH?HG$-&dF-yfG@Z4G2eeTL(r>S=IDt} z1w;$tSU&ihIZi%eH+1H_TD}W%eSn0|GMJ|dCNBNlxu}wM+2{+@Ez0n1DK3i;C zyBpcc)J24nE;PXj&Z3nU$CNZp1b*;1S=7Q)Tls85(R9wL%Ka|z^-Agqm=U%d% zEvp@wCqZ2!apavcz>8iqdy~}>nmc0=LA<-b;8QPC)98(_S1oCP zJperX*}WB`BVRtH3+f!y(DmDfkehGq7s+@P7cls<0fXO&{;8v(2*HX=himSiOE(^Z z(mt|1lpQ_3U*&;K6V%T`h3b!&>hnSOZR1Ka@45h8O}X#lC?Rd<>@!bYq7D=}(XJ<^ zhnb?0D^c&6A|+Y#z01^9EnUjX)$2}H)ppKV`WR5%tWXp3hr3H&acZy995CrapLCD7 z_tajQP=pjyb83T}u+>OcJ9JFKVekR04n}Np^@$NG7klCC;CY>UzGo=i>!o1i0k<5q zvz5WO;GCT3kyO& z=MunT6~qUT<9Z>-ae9!*cW7waU^t_@liPVRzmZQBZ+Sgx7z?6mAj5H5AZrQBAC#nN zoBJ+uq*e6Gl7*Z1$5lorFD*fQ{#h;mgLpJ5hUQ z>k(cFlJq41VFGQi>zJ`0sW@$TcY|aPy3W zYrM`x8mlug(_ky7`R8h%k)x@+-;dAERy!Cq8I6f+E6nn9DfD#%Lv$ys31=6O6ii^fYOyKwA%5%eSV#!VFVTfA}MR!j=Av zSYsOuthI-%kPl_Se;e8y(UgydSU9C4!+PD{Uws;J6I83{htI)yIr91-UWy%3begR3 z^chw_UErL)ok?xUn@mM%HBEck6K++>rI&JlqdTJNFb^zd4X?K>T5nA)wM-N_xS%$# z(z;Fv`Yl#n(##GAqp8tTc{H?p_7|mNvtbPtN<~QxYKWVPbw$=kygt_w5$&{#V6 zg9|!XUg8^Sq?+&1ru2fp^{=p{MumO@U4IPx4qmtj9^Dn4Uh@|_-! z)IRh(`92Ud3*Qo_G*#I-Om=pxE3=m6WfIMq>_QQ*jNTNIqh3wpuL|8?(9<>Y+^vDi zfMTsTW!bnVvr63skYLj%_QU#itj8*B3)&j1ChKe$aba(3OTkz};c{dg)e*6BB%=z1 zeMGz*=JRyCX9vIL)SwZrXZ<>rOfY@RwDA@=rmlWqA6v;-RG+YB1Cf0!4ZN^EwgQou zKH=}jt&{hLNP_Mq=OrchY z6a)#{+qbg(Bafx1pwoEvw)0Ky^81P!oQ5qe?Qk6CTx-GTg+%%pR-*ml0qu3PYFk<^ zV)Df-MsXuVo~yeNAI}IuK43^9D@Nfjd!$84DNBYVGt+^nQI)*>gLcf}bW{gQ^+htx(M25s<;9t`+ z?88QA5dX7keI?xqwC*&&$Oge3wU#s8al5BawZF5fZ8jt> zeIFJg`-$ODW4*VD#IU!`R7N@^CNn<%ceaa}cA#kV`=fXIa)Nr}(bI{7PN0p?4K`t2 zHkL*}Ppetyf}eOY{Fj`-*Z!9VtC_eDPMi(zV;BO#$rT1LI5JbN2>Tf)OWtS3<_HDD z8N!$>=_W7TTw#=zvv-#_>OOcNPsAbbSv3c3(nV2{3V+PWoAa?i&g_q=W99hA&_>VY zj9%G`=Im;EahaUo-CP}+J^CV(J>!dk>@i;)%%hCS;dV2MsS(Yc*}<*`TciAn+r^Bp zjP6`U^b~)+f)8rAdAYc~JNp>V%Uy~NHFQ2;@$vXhE=>GDELE;pfB8v*F|26pP;dmS}Ykm zogE3@nzyZ?f!i1ys}9U8M<{=rjkiq#edUgBq73yDJpuF&HRp5>1!TF+X0-%Mc;n5n zPTLt>-(IT=eQ?6Pk9OMKZBi&l*RkK~{SfOxmAJv6b4ogHDCn;-jvEcM3jSE&DscQr zkep8EQ+E{51sqajU8M&ZdxO!%B64cz%wwhv=HQC6kIuxcIW6i?t^=!1BmPs!#MNoj zJ@>w}4s1Jp^s??H^wL;Pv#leBI6gK5b=$9q&7ib3?i-Jbd|=tr_{ayH-fV~l0ysWI z!#`VJZTyp0d-MYujPXypei{s+J3Zzj9NOi1lr8$PdN{ZP^vApNKaQV`Eh+9Zti_$A z^!PIr%x>VT@`$lpFv>F|%RbNR1*i9Pp5&^fVGX*kmBoqoH8r!h8T!00yzS4{%?#}4JknY4W z`ejxkrh&Q?I$5yI>-6mM;^W!fn?J^WpA#7Q`S4qCJ!p43V&LN)U*N4W`u0PM##D4J zO9dPN9IU%<1 zaabMWfc8Mp&qDA@>{7h1nbp!#!8ugmSCWoxz@@^z2IpL~=s{fX30^l?JJMZJc|ccM z`vcNSGxTSfp)*MHx`!6(4(GT-P_@6BgiK&lwf}PI%<*?;x)H35`(-Bt9Zkm35Ol!> zNGKYeJoI4V!qK+|iiEsemvm()erD3=(Ve7@Uo~frWayjH z)XGFo*Ppg+v3&l!M-m*vZDeljOaprBA5p=x0S##3+l)piV$S`p0`YZ$UZeL{a*guu zMcog#MK@WoAOFzPpQAv_ihDy8#lP@fO=Vb&a3}%hlRB1$6yi21_#z?a8FQzuC&xWw z^d;u72h3jVUhNNG?5K+PJLv;NdJ&q5zAW<`-JAto`9UDO#jsJwyxM1UWkrP4SF39b z(E<$&-L5B{~;w(C-Qz0(e>L-P$1R82)~csq4aI~W_Ml5 znD}}tt~x#T6JyEHu3T-3feEnKpP~Y~sh4oM9;}a{)Fij82>oAC*WX+~n--DH`Z7G80BB zSXashS36+xQro&k2l@`Uf}i;6)NF|{Y7yoo2#JZ{^8c3Vw41&u&}q&Yoaw3DGA2tk`x zjbf?xZQV8S0`_#F{0`)Tvvtj#T*NLhxH&fNF?1n~t>O=dp;HlhvZjBphPxVoSx|XB zSS}ed$&A=VVJv|^Fu&W41P41cewZGLef*O~-O`jzMa@>77kkS#dE%Ym1+-{;myjKs zudM!d%?e^ek;3xW083I|@G^rP=wkC?n*}w;=HYHNc;&H1HRo_)ZwS_)T^XY#%Y%>nh_JJ8<55NtJlmOR(>V3vaKM#pPJ#R!J%sgP4W z12^K!=y?4juWq-J_Zy%P9U2~!F8R8n zdwq&RHPN0yf;;LxykguWqkeaC4#m^%?I-|B$V8i zw#pPzsiH;+tM697;vqABaqF%g@oCUTE+Df96jyMv^Li@d-79}*16nv?Z~0kLJ%!sX z2(eTj$p+B1Pu1$kpSOEKHKMdGt%3C-bilOQv6>@66m$w6+#(p|jDss~%9dyu#31%Y ztSGusU|n9^$>_L?v^!$g;rB3`eU7q1Kdj0P9z|KC_KQ)yLfp7)s7tYu+eIz|N9b`u zw+HiWC|4!?Xd=xuUGGrwXTcUwtA~IwYdaViZJluy^GY^Ed{wPwZi-CpIK?<;$aSC! zw9RF0TF^tVJGt1!ZG;ML@c@HFV_mWMyBi3(Tjf&z@uXXoPt>RC@T7JI*%9! z#n*dxsQ>hLepiRtZX!j5UA{A7w$$H|s&dy2`Oy*EGNvL7Bq{)RR&S-3RZSr_D28N9b5)l) z49Ujm4F%1GCxv1f@d`bswUX@0*w#xJf z)xzI9!9=-1wFkNu3e(Ioh9@@NT=dM~Uxf-ubML zTkvtB!*`>GjudzU8Mx|c&l*MyaYuQIcL*CGQ(d{gqg;eTI;-xOLZ4v5)~;~T`i!nf zf^PX5)Nj$!bLxEztC|_qx;JWuN>qG7 z*9cehDW*P0c`5h?m7b~HyI;Iy8n4V8SPho0uUDSaoSdj(>`?Ddc++%83P+3TS^Cw1 zwiBya1IJw0K`ztpWNd7!ob}qm3=pES2^F?sC%!W0;uGtfB0Z?DH-%XO-Gz6#_#=V} z=#YNih_+T6GI|?9R)VI7UM`Y4<7X#o5VxN{KE-?7JtcN+mY`M%EgiKz86#J$(eXqU zb{B?K?S6XIR%A{Pq;S#FPD+P&(r>nsa~HRkgQYEWA9@YgE%(!o6bsU;G^d_NMgg_P zv|?LpAYJ-&!(Az-3W(LMi;2xBH!kM3Qjb^bpBHjlW`GYXOqy5$5OmAs0*|R923pZ{ zPZFx^bmIwaV{sp&b~dn2(?%!QkgqUe8{NREDYCl`jemEi%&!ev_sRN~!+${FlZ zHcqzGc3h|%i4qBQV;m`jg58+Lb~y7q(CQAxXx#Z4#f$4V^%@Y&Iyu)kmepb3l>X#R z$dVYD2@B#-_CpvJx?f!Z({x5%mc|Hsy4j`&#|%jhu*ldAmWs9sw0t;QnR_ABy(9(_G9x-(P zy^>q^2KHm!xWtAkmGRu=+a+Y|HDbu2Z;O0KP`}rPwV<{p;hQnKC<0eudaW@!wR2ss z`#>Uz*1*a=2SDzo7-*Z~;Po;xPOGW1w5p~R)&w@?ugd_n9bC7%Erue!M#~(zWFr>F z&}44=UO+XsMUZZ?nnx+;yhiiF+IerYlX^0BoPPR+_J2b8p~+Hv`50z2Wj2)2_V|!@ z9g_?LAQ@!}j&zrG+d^ zp_wqCy)hjgr~S$mWVF{B%YC>u$ia$Z*=WZhcJ0)NdW*N3Ayd^W`XQFmG-G;VL3*Oo zWu4P|i1Bdgh^9t&_4*N@ zleSHVteu#iL`DTF%^x}u=j#Kr9Nmqb+CqZWgoJ?0_Yu?F+6jZrWI|YsLGs;ccnB>M{Sdi)&QV5@4XYn~Vfl^qva&P|fM95u ztS#mpV_(>O{95-pWs*@(rBQ`DYadJN9hlo_F5};Zmc%jIcf3dI|6J8|omGrux;4;N zQFrvlVb#yOSnog>FTJR6`sCZzuRHAaS4Rq5{x_tvA`ffaF%Ic#L=ks;2~Bv8t|?yq zLdzc*psHq~UnS{pc|xjsgQR;{Ao74Bts#MNnGhbmsZwvsTzX3_t5TlKP{3iNTW`^K ze%VI24{MRB!>&ZL;6I}vGtqfRvhS|23Z>-nNlTp!R)*3F6H`nrANnU4%)$t04SO-> z?cgP^wD68j~l_!L|_bWhT16H;H@MXK}ElsYCeD*Q28lcY+x7Usr|c5A5SZPN>5$@|$`%j7JY|2C>7zOVr>gF>@zG`E3vDMvu}9; zL2V(cR9z;K+eWPA0p;Zho~L=>WbH&}r&InZt(Yg`yTeV*CO7G*6=kAA|K#op-++qP z*4V=B2&}zdhRju3x@IORsvf5@yI8?r^U3=uKJKQ+7 z=|l7I%~QiwMy*uT8Lc}`n;Lo@%hn_0ieYn^r=d#a?lEwAy6z5QDBpQrK(?|y>|)7j z5`9agSG{>@9WMpYq9OIN5_ECEZwxs&xRD&>d4%>Az}-$!nqS9~HL}s2OX>(HUQP5b zECZxauIyeOj4$vP`cO+li|EBBlTkl4WK<2_ytuyTW2U*Mu<3(9R{|5IyYWQNay}&J zTyGTwQz;Vzpq_AXI6ze=Uv&}=$N}84E%-83nlN{7`zo>PSiRbaZC0Jo3%7>po))%E zCTCqx)xrFA5mt}L<&}Is5|8nqjJ=vnYbSz)S(ECGrmU))zTQLC=;ce9LCtJU)FZ3r zLA3#=4X5%II?c(v{4CkrHcb9RU|rt{eHlf8^k-T6#Z5y>&J*3uRBdjjdC|?&q}n&H zq*>QHjyP8@c!O4xyW4r_(gtn;Gz;GRQO;WWDoP(%LfyBb&XjiB7=14Wa=XEK5X%4? zUQ6>Z4ve*Nmkh_f!8`=qUWkTeGLWIEae>KM5_J%bk!cC@cUJR$Y@_{T*Yjjq#BvfC zu>rfH$x1xp`gsp$2P=Ckb~^o-+}_>X zo?l#_>Q2dR-Q55}hz4z%R`1frBX_mkOIj)dg_=XYp>Y?i!6zbzPkw(Qsuh0vfo^T( zu!0s<(gojGHuNAPIgNfB%na?d`P|%2=O^!mv!f5!{LGMVAfFdjpS2aRNNMu+Y(A`m zc^KG#u{Y6or9;d7?{optLc_a^q1D;g-V92gcW2Y1>R7#g1BHwdZ@R|hs1vOW9xxI4SOxf@ZmU5sNTKx^^uk}*vY zSz(9t9Sr1YI$5;!K^^Jp8zzTh*`G((topkxG#X#~tM?~2m&3|0^&Lw(v@*MrJYxOU z4i+BLKxK$kV|saZeLB61=pu_Kppq`Dfv({>h$sb4&o0mAXCpd@I(`n0E!|ujDG58W zupTKs%*Tuos&{I~%yAu6>L|xDd|8&)s;oJ+Ze}C&0voUL=%NAZF%u+cc1&vM*sN7G zD$}$wZ}cr&HFjRbz#uzrfE9ZC zgI`ytju?Ged-@Lbrt*<###c8VM>Jx&DkQ5TqDFKZ)&q}LeLXI3PTr5G5Pg;^lm{7t zIkO#wy3nRqeK*${&-td(7QAL3uE*)7LcCIIf$wK!Tj$2_;zeUYzQaj}_TtoZn)<1CiOv6Ilcs=S%EE8v{GTxK$kQv*4{3Rvlv|Fivez;xCGh$=2^fGTU%iXLH-)rn_- zn(ZHdy2oWznEuy6I(oU?BU0=mn(40rCRmYG!OyHQKW@i^qHCWh9Oq&w9rdD*$A& zo&&OoWF)KagP(}#IIQ2GZp09&9{rSSh?kTHPLKgM|A^zONW!sPFCA(he~^ zwgW9Rj$!)dZKgiA?30uUsZO=(*nOmgg_PGD$WyCW1k<$7&^Xc))L<7b6tqAD(Pg0RC^6my>g-DpI}dIFXg?7mwhN3M z7pJ~L|2451V2UkRg7rI8vjcS+uT5C^2PhQxAx2}mF)WtP*3RQY@YUIAQ5J_C*iKAc-iSIg7sd2Dv0p~9_}xvGOi1SC z7T+gSid~XL{G6`Cx(c4ukLH={?4t>PX}_CEKN0kzxS~r?bbTLmOkGrp=Hmtr`u?NH zx2g5yHl?3Pe|j(0kWTl$=zi@~`Vp9M5Nh)ps`$GDxtGnvGH+Mu zMKLu3GljdIVyC_)eaD=gt8~<7BAp%opO(uO z-$YN!Hek4Dq!c#YZNYTZqiE_FzmRspI}uucr*<+LbxWeK@_f zM&6}KoS)nh(67*aDy}z~by#M#N|Y^nlI-%fx=n6r0N{M*{@)j$67Q&13Sogng= zYg6ZoceCkiHl5tgW=dLpjO4H0p8p^{$ru&(jtVT2*2G5gbo%*+*F#9a!XTlbxdaO2 z?)}N^hsom)_dna2v_<*saH5X>RX~4E)KPfjDE#hfdJ@)gJD-gk$r_2(oXipzcB)7+ZW4o5Dgn zk?&oLP-RG+S#y{LPr6tdhP|iB3t=Ug%

(<_LOFr6&oAxC6O1m=>>1W>EB2e6xqMFy%Q{6JMIc3_!=ESH=r`9RM zHO65&on5n>hX#2j^tKP`(BUdOcJ`%;2y|FJaxjjl-BdQ&i$bGwDz$p9~S z8_i>#mmXtkzwiZH?AjV1?_`2!PO<9$PCg1?Hvq}!v;f8FHUYU$yRbv%(bmn$u#Ohr zb5TOrJTb$cF+;>mCfM&R6c^6h3WcMH+IBiY*0~`aIGy2_!rwcCFL2%ZZzuQzuXmI> zqXc@3!f~T?yuy_eeb68>FS&84DI3e~F{j@y!@174!^jp0NzCM>1V*IpD5eaqz zY1&xqaq((;n|!eA3plRrvo6g=A=eyMibQ7HeLMC?O$*w1KHOb8rkrf$bW$1WjOGTH z)9Ry=59%pmHu^}vO$Jrd28&O7#DzSz^v$iB*WOn?=MX|rXxV9{HYbYc3yI>V@KU&>S z&+Lyb0!n`&-aXU%~hyydr!5`#9Dfr7z!%lfFzBqA0zO zU;Z&tJX;)~|4`HURqVtjtFnVvh*#5bXjf%b!cN>3zquMGezWsS@wbtm{tb+@l`A~s zgpDpM+Eqq*_uI|vbli7mEmQTg*+^j;A9;w86*xOUcT*Jz>r{MrX6a(hM|Plj3&$jW zQT#D-82SUB3$}%8r}NhM4h)W)U@+syIiM^=_6cp|4KCNQ223wSfV~sx% z95wzV-{94|Laa9q)cXF7IT5{S^R;l>lTNfHHw(KZzuCZ<%Qvg^5nT*{{o9dEda)^8 zpz_nc4YV>|{`z*T{B^o_UhQ3E_a8r);#r-;u+K_=#9;o7-9r||{hL$kT(MZ^BCwJ` z(kiVtE`nVEVFV`o<^72%JkJ(j)0CGJ98Icr{E0 zaUSv1ahVBw_e)7ICDb_H!x3Gg@W1s`3xivYi_uRt4Oi@99v8cSltc2(<-fvU+v069 z8z8;E`(T}Iq{~fe0o;9<%`T?b$@$so+1(T`GS~>4>i)ybhN$59GmULo@OZ@8t1NfL z{rq>!qKaF3C^78F&ZbK~3nW)Pd|zKyoBI!DgFmUjd=5o3#|0y7boI}++Gh2JAICpz z>D^TuxV}Fzr?-~?m?LjNBpuD$2oMK>7%XE?!7$x17O7Ew0%OeJ# zf3*5|i?&4JOS!!@C>rQZ0P^N6Di6z@b=K~Dso_s6(eS5F-bLkSAP5UWuYN)DG_JHv zIrvh;N-NQ@(idD+aWe}JC$8}2MfBsB8T1A?#(|?8w`GCshq!F}85W&wwf5zPbKMDt z@?B>3gnC-8M=!}%(2=bQyF^zx*xOZZXJ+f|@&4+g`Q=Uam~JvypQ~?Q8p~UeuYhWg zm#Z)LZ_GM7{Zba|?Iy4$+q8|d$4K-06LXIN-9O!0^WkCdZU{i;?OjX;6P$$)$#_-8 z3kIqwE$*l0`uz-6j#*$7o5GPVB+}yLji?r|$Ma9GaR0#i;M%^~lELcY2V%ejEShb>^EwQS2WBV(C-zk5q7Fb^C6lzPGqL z-S2U^oW9^3t9S+N#-jFIjjSWCpf_dm?0uGl{Yx=!$<0cEe^ zvW)Qpr3O0rKQgd^ES{VUS`E3za1j`@#VH|Mq`sftIVZgCKvb>KYu6o6U?+DI7kmSU z`Hz_=c5)dPJK1Euk|zV-Iw|wgFGrBO86bQjTN&8z ztz|*ol!db>R%y0eYxk!&qW-fTIBg{v&#mjpp%rB{g7xV_m#aK_vM-8I10Us3Wav{502H? zmt>5^51g?$BpJ@9wYB!e`K>j{4S#!RYyHqxwoT!@tvJi1Ep)JV)H8u`ozJU`dLg#x z>#~Bc>6FX(9vk4UFRff;Zg$=~kAX>k$E;1IATAPf|Lt5tpN~W3 z{BxxIaoTB5r!nf~_H6VPYy!){Q)rU%>>VM|Pzz}7P3qhBlR(FA&pdR_?o!u}b^`)a z`sc3w#7zMkVQ+BXiMAF)+uM!U+P3?5V!IX3Gu&@ddsqK1T~x3&j&JHWjven^24ymG zOTWn;?$3XfxF8M^{}5zCfo@86jd%)7SmPt|3j^RdJI z)bgs&=%scZNB4*?UT6w)pU{gRlt5F1cn+?e_k?E&fGpt!0Busa;e47EJ7yj&;58TTGX13-9jVn{DR(W~ZVh zb`5m5DBWRd>sV3WivsIo2CVx5}igR=8?ZzEQTnUbRi_p16IoXZ(}0Dn=Oow}<=p=9u>W zP^}MN*h45u^4ea$u(ugYdrV2OcRu1OJ(-{@iL>m2!4{& zo!d+Tgta*sfQW4r^6Zm6cwXX51B0Vy4ktsWmK4mDxvZh zUfy4tBk85E<|p{+sNLLO+FCc8R=9SWF4dNOyubWteXDtN1u4mv`m(XtiI?>HcXfE) zQgJ8Nc1ON~9yfZWwG){u4Os~g(kN-I5 zu)FpB)m!V!Ipmx|R~wQmOj|nM(K}dRT5cp)0tddR56LdGPp_^-8FW1453zRHpSC6V zDyz3y!&{tqlko1-lRIj|(spcJZSSw%TRB*!E6*g^rP{K&+e~tCfdB8te!IB8vgEPj zx+^4|=tz1kw8)Nd8r>C7_g7c;r+NR`gTS+7Texz+4dc-G&IRWMf4GIle;X-Yi)-$$ z=C*hfTFD{Jkv`bje$!S#?{hBeg>YTbV55F5p6Q7u(LA4Qz$^lb%ely&oN2aL++W{V z@6l9GDXmVwc~fq8|KtCcTPp-4JH~vNv^;l}Z)h(27S0+zmjyfRahpX%vZu~5NU;eN zHqO>aN`vLtakSVJ_Sw`4zIrBds41rZn^i~N52yA>G#AN}Gt#P0DY$XbgbB^zJpr^kGfG z^t^mF_iwBdQ)u*XknBv7Zz@q|xhr@(9~6|Sf)RB`j<|ea-1xKoVtWjnwDqz~erwa^ z#GWVgRN@k!M98rs+;QdQpHnS<6{x$`z(D$SN_?fxSB#!zb4F ztEc-rvn{^Qpy$H?S_Eu8cTe74y>>e4OceDNHZ>!QsTLbMzcYbeuHXD2wr%sRpX(wy zha;WJKhCK|<0;aJ(c8UxY47o80w0PW+~n6Q=c910FnSeD!n~#FIGog5J*ufmh+Q^z znylBgZ7`ULUAfMhkd2hL9Mrg6yRyS4j^CBko7y%P&o*uSB=!Rq^*X!1d~cWDMg(r3 z%_=%(+qwuVdvcv+tI!2Hc6P0|_cKd{ynGav5423Nh4TB^g(H-@jZP=plDqrgXHH!O z%9%*EaA}9kn87d<=qNg9hAVHERal-ctI}SHMCARY2nf$^#tBQ3BmU?8^wN4Rej&oA zQ@rtNSY}|EYJ1cSW(_(zP?Af#lsRE-90IDQ}0WW$6rb2%&bC&`)?; zJ!Z{YH}2wl>}t7ww4JDCPw8re6BUVh{+B`7z|sLwW@m8#OmZ&9*H2EveiG7R7;Vr` z_w#?mh32C8;y1)E&RTGm<=$B*vl?ui340E6L_Tt+0asGcACh*Z{(A1WiY8TgZch zRoVBr)P+_Sh`G`Q;?}WaCmua+Y-+dQFpuL3uCbT%@;)xRm+*HnB>W%QpG}%)4}%~w z0PV$Z^Rt{H&hIzC-uzwlVvxW__1)0Ep!gLsnE!*17=^wP747MhUIk~zgba1 zuMRfX?%*&0IkO&g271_Cy5I{I<2_F=Z?6MI+Ti;_lcH=U4`o|;>JvEuaw5sDIQvQeOV#q# z61Lq1RbF0NPu*a^e@w>6J z2&*V3%d}E+d0Kk|?RA-$bUD(>GadMd2WRk3_Fy{kTf-T>1dlX&aK7gcgTfplu%W_q zHF<#b!6pDoG(?4IWtvEVC>S@h7_$7-!lJASSWzt}H5f+I7~1LeY<6~%D83k~KV|D# zA(T6{LVHE;7EI_J828Nr-3v7@y%rloM%sA1Oq#1#k511uZ(W1@N; zeA1d(h}ff;Trq9rOCshAM+!hO$friqRTLz(+JXmxua5En+yd>i&jPbN>qK{-Vby`# zAb+a3`cK_>BnQ`vH4KcvAs85c)sq<`aEdn1C)U%+*N~F*s`x!Zi^A?P#g{&P4Q5yK z+eDLNUr#rAIq9BQasbZWUEc8TFLm{Zi*Wwy!{cFBAwZg7rwA%?HNCh@&hKun;@YS` z*lkNs<0SEcV_1&{6}UUOohS2w!q6amd1#1OL3E1*Pm8N=Ss+Qc)sheCbh|AEkh6sE@N;)RC%5mZig5BXXI|5}@!ipxHETE%X8=BJ$ zZ;If{p506$9x(WV6iAc+3t6)ZpV_ru=p;qJqF_PbFih>)0m1Z=?g**X&^Wk#sut)D z+@2iTac?^ax6O91_RI@+@QqGD8C*QMB5lzJJu0esT-gWar9MlL>DQzyX4!4A@=d-j z(|(&pNh*6*vM+sJ(s}z8)|4bx>!(OPfwrjIJ=%xT)x>`#=tECUbiQk@UQ8I#J$D)b z>X~9tOMFuUZB5x1(F~~O@y39`xH)lNkn#Y5Cuy8#rMdjasn1B^v1G{Hf4!c!_ zWHb_N&}t(&0zhVCdQL-AFro$P2CK>xU#SXeQKgSylvqvVvBSiEHBh!!c_4uWqL@99 ztiYugsENZ_SGl$QmT|}7v;ptI%U4~4oyb=eSFTDOL!ueN5U_P#H=8hmq=VhGZc`Qp zHl*AJrh|cTncu*m_1GJ;uB7!RU2eJ2ibUKY#}HxKfcy$O+Q`Q`Bf|~J^5YH3#s(ac zWkwwJc&E2*D(Y8i-R$gVV6Uc^%ic}~gw#H5iBWa*Hr#FzAg`9pnu#l?9tx(WbP!52 z#i2qw0Rt$!6X;>~Rk;^ynLjK8I8Wfg48}w=dT*Y-qGx!$O=;2Y&B^Z6N;e^L*t_dlyu_ln7=IyH;S#DcR5N@TB93>{@lGe1V zV8(Hl3T2#VzF@tFe53(MN#sR8L)BGJbR4PAI!woc$$3Y`FiOg{4yRd~*NjrK6T!-( zcNt@qN5W$&kB|bDM<9{Pb7Z;7b0KV#hzsCZL}!o(Z!Mb^6zz>|pYc@Juu?x%if@>shSoP$c5UVAy6@ zBcKhWr(^}_*r4^KY+$+;XrpzOV3d`{77%jWA#RB%=Z4(#f!N^%_H0=t(#9k5K z4A}$XPzTlQAgD<=FB!hJBvX>(t%>S{w`- zuL52flB(@<5%~*XNf+fMR{j1X)%hNT0?d{TfGFwRl1-Y`6I>T|QhV9g!UtZ6I$J@M_y1 zLY!hwVPCkJP<2|@x-nVSGEDO;;TAG2h{;|B{Yk(P?%wL6L{236Z^=~BgYqkRup94y*oxRdmtJa@3{K+N4U=9o77`~Zs`E8e`P5%46$6T~rwEZ@t|!8_?ku0j3k zP1~$sdl5#PX$~vio|tUl)F52z^J#(%v3hqfn3{J%xVm>x{MvUxnEH1x{%i%l$CX)I zU=QcFo{Pis`lFWjyCI0c5|1VYIB)!7&6DrST3+0c6m+fuq{(bPOXU2@A<>i@M58(P zNJPCXP#pe>APiBY%~M%zU-_p-*OI~=6T#1QX&7ysDe^{LU?&g-o2$8jUc`59%Z_0!mrt_@lHE z>vff`5jLP-$AHF$MT*S=Y*?@_iKEkf6fNr5=c^d@TRQg^T1(tUd_W_7d_&T2j|&%E0@EB;~{Cl{fubS+*-o=r%PEbR6M3;7b&H7daNwaPN=9tFy}x zo*EhB80cCV0zmi5!3_2nK7%+G*T|xSQ3|bcZ60uC?x+JeWJcs#m4-rwScCd1H(lK( zU(9=00+RWX1Cf?hP7q40Y^!A&7~Un3FNaQaAy&Nk@r}UNrZ9MWV+Z066WzDH(Vq4Y}0dEDvc8ceW-1Xm@2c^ULC>Cinx*Y3=5^FYK zUtjsI|58{|nW`r%U|_m7ZGf>^TY`+4wt1^!&4Y2fX(<}sN;A@Aco3G)K8He&Bx=?W zqQ5h@p_pyCCGYLYZE=4?E~R0^(ama}FcOX12fnnP4!MJ2387~S_GDN!5t!|vb@=T| zwhl=RwXe2FKkw;Ej3@u0BP9|l06{J<`tUeVfHbQ1OddvXG?yTM2FLVz7j{6TdqdIQ zu^Z`tNJybxv5Pw(I?-&b(>*80@&W+M}S?(t*SV_3|+3=_iiAhIv zMalf~jH^Dq@H6i0$R0(WTXy^fFoBHuE{Zyz^+W?-Me`S3$8SZ~guaT+IFL(}HgB?ho=!SA6Gjn@E6A#}YgU~_`FXM`)0)a1 z4s7ej8T5c5K?W*z$>6UBa-mQ3^YY1_Igq9f^d-%cR=1G3GtblRs8iiW4odq4s_!ok z6{q2Gqm6pJ&rL@SB6MyN%YDOPD0&Qw+^%=&lHSSKO+rgO^uJCzw#Z_y!-QEEnDxBq zL@`1%&A>)7QmYqgNTd{Aa8A+r(pkC?2kB#Sga!#c5cuOnXo#o}MI%1@OK(bM7R=Ua zm01zo#T-G=mEhI>@TFuzyI?BwJ(O4#^&$`0q2X)Q0aq`l*Rwa5o@j$HT-j(|GjwZM z<}lR5#EiRGiUo`Ae_Zeg1FRNEM-#qNlG8$Zc*V^1!3hx9naMpk?*V&VJ~Z5d0Mkjt74UCoBfCmP z(-aKFt_K50ar=m7w-n{wYL7tF!$lQ{c*Lq7I>Y(`+)#yfb-{$pCutq#1)NC63;wPLef zkx4&Pq-5BnRmE!IRp5C?JblB|9|7zR^`HJ=a)nVgLn3<_sFRcHV|a#yA#>ZB(e)0~ z!)n$P<kgY=Lrby#S(Rl9d@@neVW zDg35aVuUZwoc32{xPv$?Ut=`n96jWH08Ik>4NRsibrplUG&T45x_R{fG;km z{4HIB%!+fXw43gpg|$FK=bGA$Xe*J%SqJ4v7AOtr4(+#Cl35zA(Y~m3QJ^c!{OW}q z{czH!d$WN&&@ik$$6?RAwXV+4P`vA0$B7!5NzB0CG;%L68bp7CB_K;LLN|daND{GH zA~4-t38QeiQgt=DeAD;K~w{7Z;XP|IFEFW3H5Q{wVD z&*_T4-zj?Gr*wf{dLF>5F7*i4F!x9#a#0ynr#qoNAZg5vABwT6h5qT z@M2loM$m6No>7pW;MBDc{(SYTOplghUccI)8Dk^1{_uqESsm3EMxXdWFAe25-vxoL zZ$NQ367;Db5$u!+1ojR_QYXxSNq$@H&G_8wyW11SVJ*4rLL zPhMNkc>I;&_^U+44eJcuObx^zO#Z+AYz>G%{F_1h;m03r;x7jA^fzk?Dy77tJ|GLVkp_Dg*^T=hZ6YsSLCG5=&U|FvWO$zuNLrm&s_AzVtcAbqaCDlVz_P20p;lokH<>OT{_ zLGaIOO7%adqDNOEOvgMi zJFRkCGqp*tjh=SypHiDygBue=6XikTn`NvhVfHbnd!~t_s5x|gn7?zc)pBQuu{Piz zq|sW=j1E7aQl`{R96eXOR5!5WYeiPccr()pE%lS@neMov`dr0f~hIYuQE`kq2!m;dhZU;U)L>K2w?R1TT*59_CRMwDE}(? zhG=lY{r^gS_{;zIM{9tvk54}07-As74!O}+D$#AEQL`o3hl)HaQj7~Pz-;b*~!y zGA%@vmF`D>_>1*bFb`F3AzGiTo2sNsRL}U}|L6bReGwZ4oQA3ERe?vmEKkREK{ql= z>k%k^3Hv*AglV3MngNh6gr+i@1M+B}gVc%ChIYqgGtI2?ZkZ?pyiG6U8K@Jp4~%{_ zOrnX&)TO#RKcdK+19pSXWwXD6SF;E*U=0J%8j)KQ{R&Q?+)Ch3PcV{h>H*7SIGlg-p$9QPP$_ztS9tz=kUmj#3G`@SINySy@4ytp zuH*{A15^%L(W2aGCoWllR7Dt$7hl#%Lx?Bj3RHWja~P|(iF6dIapY9!@B;?HCG^T< zonfb~@$Jh1_;2U~<3X!qTRcYSK`Hh(wYG{bsE8Qku}Vv49ObDIEQ!Ge)oB|*7}vDRwD=l%`_r;Qto{*Ow^@{*W=V8hnf64oQs_k5I`cyWQ|2D zOuB~Yo@8`5w|EV~gP~Md;5_M8iANmTj~I_S93NAJlMQ56Wcz*EL|eM_Y*F=_)Ka20 znwATFvBDKMi2>L#<7o`;qmWyTI~C+U+9n?ra~~34yFGbMCmeRXfPL^frHCAZI>(Fl`M3jR zJ06(Ki8ETJN6S}Uu9U%o6S=Gpb$bJHuotS!uf#l}2O7{HWxN)@Y&8Lf3ln{Crt6`H zdmB?4v0@n6!Hz^7Xai%=ZlNULxJ1Mkv3t!mav|HH4px7MJfiM9)X_t(fj(jav9&(_ zBk=*s>PWf8SLa1dIV`?Pag|6(A}djaMBFtLCuM%;+CJK;Vehc(? z#pBJsE0Do9->V$L7}?r~fd<<7FhID48wEeyyk{Fx0bYOD7dO!%w{aWavvJrm9n4tip<5^u3wD9W=TI=gQ#OIl+S=3GFA>l>eJo$5<#EyjvFL3 z=J;7w35;7NX!PM(R>OuM#!jz8I79R5ko+0mei~N;@}g8|nP%c0UHTIHs5+nz4KLQ5 z4-7BYJosm3W?;!?71!wIq_Po3JF;bsfgIV$#y~|Da86Z?Si+gWgNrz)8IM@TS@@&p zQs+ZsCe`4Fp4;}0o@Ij?9NEK;op$5jeTnQJ(GQQCk7F4h{h4QV)@Od}s9qfZ26U?? zLu+5rj5-3|_xywBzzp_yL$3dwk;lW_SBLGd?B_;6kG0A^7k|iBI|}!ttkSdPru0xS zF{Xd3 zc=xPkaApjSD*R)Rt`2wEdSgEk+UtZ5WbQkc;2Qm9g@$*L@RmaW3rYGc0XBd=V)BrS zwLBvZ;!fT7pe{@!YZn&Dlh%qq(#j={e7_tA;{3kvMF{0 zH?H&_)sKwrBQU%n;$oD09*Um2ffl5w zOg4NF$sw`Y_DZSX?-}(eW;ShouvvB$xY4?XAcO&8^IyP#L3U9fBTv)#&=UAe z%tOYs#JiM!_=Snd)c%4Vo>}K!=8x-giP-n01G@+$1lwWm!to$Bp05x|O?Qzo?iIdR z4BD;yiDH)K_RTkmh_NX8VNN}oB33e53KIohb_B7r-`t90l?C(+9%=^5j=tp~5$p#KR? z!4KgB)B30BjqSoo?_Ce;ZB@d#p;5o`)C0$SIRhv+Uia2rU_F61@VxZ|y%6KCClJQz z>QY>GOs!JizwvU3r^ttFm3s(X!)=QU_8$FXkZN{wUWq^)Y#JU;q+v+CD1eCj${50- z1|D2!ly!x10`i2ff-?}VYA_bRf47t(y$7nwxCZIfnE5h+UvY$rl{8b{Fac1iM|m-* z3uw8}l#7ixs6OwFBgx5P2#F??0i+WQk{Ji;yu++wld)NQn~r#NUC$WyjcUX6ZuSGIy`b12U}5p!?rS6ZnBamJEiG9J-ajpr#KghV_S$n~ZAu zd79e6?;L($pTwZc!g9Aq#>X(~AL|QbVmo8626y*5z4MoPyGlkQ453~LdwtpKj8WSR zG>pTCmsgGD1h+UbvAtzZSCOnM94vQKnV^ek-iC`=%42=nyHbrW=K(qJ7{$C4c>Pkj z?90pqiyhAv@dM|XwHMT1Fq{PYT6~b_jiFYeA#X!PE_c&MBEDrypc^I!<*&BT=NJU{ zEV%D*w82_s6~+C^SWs`L)|Xp(C`eJoeD=Z2;WibuW@MDxPil1ILU;WUT3(6+&f7z8^<- z3(KhtG-q0k20p5DjKm%2A|p{obQBB8=r9c0P!HjhqK!%vb!4|0nd4aJVf7nm^i+zG zF7#Z?SVszB9@(AnGtcWzBg@)7G-9SoHY?HNB3qVN<3fLa5-6Aa=pkVka$qzV1{g6AbRetfCM@1#}(6fPsxl5VxQz zkgE%&qngcAYkNpxM(}XaxQk71gdMtPaKl#xVaqs`{v&pyQi-+d30OQ}k^~E?@;0e? z5bwx`#Zkj&9LhTdW}zh40F-~=%VH_E0Wh~)uu$r}Aqu3UWZ4BjQ`Z=+((WQ+v9}z3 zNU!XARJ*{&0&Dp(x@x46kmGe72HxSW`w>O}$8A!l`ptQ-DG@BMQS)%BRgXdR^2{Tu z{EtEOn>Y`t+xQqvx25xlvZ=Fp^10Ky6c;7BR-N}m<#V#gfKwxlgk0^KNb|ft!Brql z>S+uRBabgl)&QcsyG5r)F*wO4V`c}j)YHos`xsLHK66cr3Li{X{dCX5O#7*j9Sj3A zr9_^?xe}NU>rGiUr}*q4^8tGK5Iu-`R%a%cSo*Cgd@PEAp*N(?>3%MB55l1 z5>LG_2AMb!uz=w5PK3WDJtrEWVWmUt5y0zoE$|%T2;f4A1krB=982r4u?*zZe2Pw% zz?9HC?fQ8lwk+?`y4?+;NvD&kDX7ex(Gne}~-Dn@i z;U;n)sGrBfNd7GDet~5y#~MrHtb>i zHozjORxkkOHv|?;Wp)6JX$>rzZVv-+UXx(KWTOZ|;fp6u!DABB?I@WO_Y2%d(0wil z;uo|JqMK9@gehPjrR!}$7_VS`5Y^Rq2zs0JV(%2I4&&*UEEnL@1o8`*#nNRw1m_nu z3ukxWFdS3pEM8acLx5iKvv8^gLSXysed>5IPj4@hZF*n^6h&Y${KDs8^k@=8^2?n= z(nCoMi79dpsvAdQSYBy!NNNxX;q3XXArQL#8dK^fH4N#Oe-Kqy!Z={RI)cEuPR0Q< zwG%|{s%RXvS6M+|Rbz43oV@{K5SYO#uvWJLxk}?P^`JEhma8%zc3@{=!?G2|<937C zC}5_#cvv-920Wp7udO!MoolIcTWUJY`1s_I5UdKJe(su~*! z>DL#BsVizEs9Q}O0vDfFt|tvt`h2`a{yzED&vsob%9YT$)^Rzz#XC8DA4}( zfN^Elv5yBnra*_`dt1G&uxao2#-Wgf-v;ysqadalkH*1z`47VC;ur<%4^BZ`JwA;C zb_b~-tQ@Cepm~c2^?oELMNq+byxKCUVMxEaf~dN_#sT{k76jHcHV&AnvLJF-XXBu~ zN(%z3S{sJFD_wtLOkvi_m>P!g*T^1q}Ro9AZ9)6A$6v_JGtH zn1d<7M35B%R$S4sw`U6uiapDS!FCuAA6vgm@ea+v0+}wZSDJGa+^~Y zFeCMfgDE$7#|nDdd&hg7C*V16f_WV%gr~aE2uLrpAxNF|VMxDIg)nv38UgBduMni{ zWD&q^wv!vwFtw%G)g37Y=QXSVqH0&;K>h6V zpsFm!f%=UrfU4WpI9RuN1wd7dg&-t)NW7epiGlliGZO>)^@b(}^d(G94D8n$n+THL z>U+5=vf*B+ifqsqsv;Zo#j41LeUU0UVvI)i(SxXuJz|tT>I+4Em)2$em`2xftD>gM zRC&mW&4wDGRmH82n%&H`SsT=$V zP;XTdfRxQW0!VLjJGDY-%sNq~vj~1wFd%wy7{T$&pTW@$FM`7qIs?=#10zUYNi#TV z?Z>0k#SueFU5xJTF7Ak)Iv$;QQP0*?y&4pe9@Zz0fkXSg%IfIuD($$2aYiUKjD~k8 z)P;-7^wD)+JCk8A-Jave)a0PNKE$A@E;J6%%P<3|b3O{t?^O(X*Lj9OMyfId zB|Xz^jV|f3n%iN#NPQN9*HL^B)lcF$UbcK3mAyEQ-z|I~-7DfqZg22$WM|+|E_U(r zI1J(xsvVRauH+~}ah2}CTry}6%Zg-2oN+srg*QUAaj3rzl+mY14u2h0MlpoT(mCOR zgznO#*9Cf-599ZM0Fv$pF)+Uy1i*A>h=DPEA%NEPh!~vLAp&5kTLhu-1!SCZpx@Y4 zpa|;HtXl~?lNyHfsw0f5Dr6+ES2bZ^RXHPp{b~v$>xvo)?N(VBxQ~t&hOM{hidl?G zg1$=XSDQf%Lo(GCLhY(;6fje5A>gjsMgeox7DDc;Z4|U$Z6RP?Z4p=+ish8%Ib^@* zoUs`PV+X{mtoH$L>|rRcdfo@zv4^4j3V9#$#~ucAtKdEFkUb3a5rb8|NU0Oj3l=@$ zyFe48G)Qve2 zByXT$aMTbJL5Z4ClwfEbrVxe~bK`IZm%JTJY-wtO9idqivJodTrY9U?&oGokx^@O* zmC7wZ>y9)A)<4MOk@Z2|QQ&@g@ZkDD?jfn@=4Qf2H+rD^Q*~TKMR}{CxS#MGrv)+{HArODb$>8WE zXB^63buv)8g~p+ng(rj6Ej;63-rAFaQfto;&`sOO9>}k!yslj;em%DzBHho$9@o8} z^Mx1e;V$Hhb#WK?#rn7l{DPg_g?^!4PQg~_ReHO^ev=Q{yR{|XxsSnkmBb*a8X5-k zDuw}5wK5FmR|bQoYhoDAtpEm0mVOB84!W1;gWfi*6MEaEAq2(+y=_81=n)*o1HElR zF6a>)&H=q`f*$A*B;WtMZ2}JHJj$#AM!dl|G?dm2MZ3fpiQy5hLmM}Ej>lA6yKzdY zw=_m#9;50=WOOPYr>gWRA4WSy$uXE`o4g#SVG5jM(2mh?4Cd8<4@{31b7V2mj?r)o z=G}5XvO!kMeKQ8_7!3z8>tWsMIKWtSVleZ(eo^C>f%k$|F9Y=j&0PlSi`uyi+!r%& zeaxz+rI5t#;RPje%bc_w0%8_A9#*%|8HQt)Iv!lN)ES237CRnZzt|ZD^p`sxoL=rQ zVApB$R90I&#Z3!$SE*BZZyln<;aImFAJK5#83D@r@c5vHAI}I--l4}wHJy4!z;fO_ zK4|aZ!$IEkais0)F=I#jRb)}akX{vqQB^gK1oo;a46LeZB(PsqVPsuhBca{u3Ioe3 zi^68BB_H(Ho)k;q>!Q?#<}?#*c!C@SdD|}XZ0ViV%Va)&+PJw zAr&yg4H=SZ;)+^)dY~~%4a03jH4xmUmMjAZBeWU7p_fwW`Na!))g^7>>ycW%&PgKp zxUZHu?h7LnfBtvmJEN{Q1icc=_(J%v$1-4yAB2zBc|nYVWIP~z$j<*^6eQ>S;A8fl z52HYRuLmDe`#b~zKh$Y;R0EUmrjM+42YqbgI{F(g)UbM}7iv~L;0raX9`MDQR1f*p z4QelT>QRPlpef-y4$F=;SictFh}JV6_Oz%MId{={7P#chU&?i${ALrr;yenF$#d|6 z^C&>3*+i~4kAn1?P4IH_Al&d;ovL_++=B~i4|ik(8jp?_5j!t0=Xz=H%;jA%?MOqA z{xwq`RbMq74eVbx<$?8;)6u}pwNoCsyLvhr+Pi+r1FI{jG1$v|H`v7Td>5;EfEd}D z27qo4U&`U3a*tetFe5b@1iSNGR_|DM)rxVW)bjqWG~}BaL-BW}AxG303bQ*6dY#5_ zyd7%5#WaL5dVCu*_8d8=je(pCXXgV6jDL{`3H$CuuDtdn3PSjfLoS5&845x$EZtr=2QyR0rkm-YH{t|-$)Ju$!n0^~#Fm-DhiODQ9 z7|?E^F%s2VYcQB_YY%@cpmPUZaE$uEj#R$d`jbPBvX1AhPjpOBXu{D z2f&zH$v#+jBY6OfyOr#t^*53S;QU+3KA66d%tFZx_n6iqEh2+;X#tLCCL>@QQExB6 zxb^w8T(+1eYvii8_y`?Pla(ervLB#>#iSKIC{O4ZDkKejxJmOA??D~po3^gJ6|MN>$2&dX&!MhVz5y+04sJ&gga+MOCc? z_pk=k@ccRokovDv!<5F`j`y9=q4{a7PTGN1)^K-x)|Ti5W*JnG^R%Q6E7MqCpUU2=zg9_JSbH`01l`!)Fl2 z8$5jwHFgFeDyB@UK%rJV0$;3ExLgA`e92bfq7C2#3b%@sZUBib-zr$ZEDBnnh8%ku z$rpFTF~LT3tuc_lr;AhZ7}M-2UBKSxF%B@S%`l7~o&XXzY=nX*Mc_fa*2v(jWQ1AHcJ*tw#y#qzrOny*q`h&3J*}v4|~A;Upw%NVv|;xS^O#m z_Qv~O%+!Yr52p8P&j!17yu`L!WCh4SWz8nZhTvfC$Zb2230O%gZQBD-n87m7mWQ(f zc3exjMKiLP%4G8(P^FlgJg5L@pw@y^rWj1CtQL#he%FLjR!WPySy$=oPnfWmhb0ES zyGol)xiYnR5Vcv_=kOCUsn{{}5Aqw|1oH{HCaesZk18oDx6D&fSPwSAZ$<+3R{rA` zP%NgZ+OPZ?e;U=J-OY*3_@w5aZD3+|gea}|RCh(ue@7b=UHjXIyGz-WkZJNDhqsl* zY}OG59!9gnAY8{eh`B5waoK#RGP6KsBD6}}`%4qThr0_?E-%;RhbnhI4%RV&(JV`h zxe6vcG!rzNv@0AJ;rDFSZ0s#BF|Y+JJEp-II)`Gi8z^0w09Fo$c`&$ayZ- z=I2&*F|(~hQ)pu{?hsz8Y}(o~8z&o4CyO-2m@Ud$)NC>w^3(^cNdS-R#UU@n%J*@{ zd&BsgRq_Ogoi`KMI%_h_*=o;76Su5%03;J#2Te*qsXdr@ozd{5#PhNyUIfh z&-$Uw^Mfvk)EcAaP{L&;s>3-LvD+%;zWo3s$V#JFv;6QKG=7*3Dm)!9(Qw)j1y;-; z+FrAEXiza4kqQfjdKl-La#`kPF;!{3e{Jr;&Stl-O(l@wM~C4@iHTn5Zn2-H52DSj z2O4AwIjviz-NK5_G?U8&#RvGaA8Cbnm#(30x!?IvpTR`)gCXA5lN6FBKbRkpY_A!% z*EZYlsfYHI`e?}ZnqjlhPQ(eu^%c1ZxD=D6Otmqm53{muHYTfhnADi&Fz($Pi#?O$ z>E6fN^LW=VgKbhDw9x56f!85{*8zbaLjpfCx-%-(I-Sidqf#$mS4}}GSrt=Ab!=qC z_~bMT&Fr_0v(`gSTMqfGWm*TYvaO?Ie$6w#wwc{l44j;%ZY$Po4BC$jn^k8QIg_0% z=d*K_dX00Ja*cB)+{RuDrm>%v*N5eg*79|oHE^DCv&6+=fkcaax~s$N0*My;Y`y;> z$X+ASVn44$nEe5X2KyfZ&xH+knULHpK4HWR^}2&8@w@Oxz260_*RzBj{51dTF#l_p zpQ+4VgsoGQa@$=m;y1tF1v@?}ka{Bs$PwG2H2>=`zk?qb zdzDal2(~0&4@i37WCzz?GBCzklCK9OUyqpK<>XEmwzSj0d6wqZrn1SJ+%yM?9t+p28$$(2ktKC#V;6|)I^kI4pGVefu5 z+qJXpEwbe{#HvYV`BrODWMAA0(IPh{*$_(|{}|1G=6b~JH)X-;a!cu^A_dqGQgqwT zmYl#1(G$&J*8OS)OXQl7nJS7|JY~ZcO&P0p&1F|S<<+Zp+)A3p7~EMhdNifEk1RQs z<d7SQPd8#d(0XJWZ=JQk*1A}0cS z&lJ6FruLDYO!WF2?pvp}4Y}}pWu1Ltu8t=&Og7kHH$3GOeg|7ggJ4R4H2`hzMwcgV zsCO#8uYI&Ac$M#TJmm2@sM=V&Y+cE9U!c9$@b2zIZNBqttsi0A-egOOW@gDsw-$$4 zp4BcprTWb07`KoHhSPW7+M^t+k`9ca14MyPDsERdJz?eynj?;4%UH`OiJ+3 z$y&N8!UT-V9RKO;I{BuvZc5W`V)`+E%cDt&#ev0?#K{}Wx{8eN=Z&SrhsVn z_Yyu}#nQsxV+2LL%(BT6?EiKnp3Y7#E|L>ShkWnHBNcGCRAoyK=~|`-fVj1u+e%=S z0u{!D55k2C-kbMgW<5p`P9^?_43kyyGrAU*n-tAmeSn%QbsStFN~ zW@CdywWzdu1gzljlY4uEdJg9}XQay2#noAIE9_>y%dAyr$Kw}FqI)=s z1tV%}b<~+k{Xo+Secv9Ma4GfELyq@H?FChGo;#OHvyFIk3@0#z$w9ii1n*D(tkM!Y zF9Vuy4`1ebA}a)=0GL^A^pBY4a~7*tV2#Y5U>JP$w6Pb@zvFK(ik5rm>5A#wpmf@0 z*jBVFhBI9I%YJ3T(ZX{5mubE(E9h=JYgxHm!J*Io_0NBu)Efc+F_BMBXVb|o(q`|b zNHa$uDfr_rKcOJ}#}`Bz2qMjzEMNcp^AG=SvY*NnQq&5?as>-MZ%=pLRQb7Sy*QuW zT~1(|@fq4;p8PM#c?t{KDowx!e6qsz#{p&Qa_GYgBX z`8PxQ-zJctuk&fQ3~M=;HNRZJ5+Io*zYs6Ytgb*0Xv-F&I$YTch&PnT!#G>156#0b zrY&lIKKaF$ak71v)@Z^qvP>=|rem38?7dA)n_h^sz{v#r<2S(b?U-4Yxg)vCYTVV? zwTCG^vy&UV?Vr{AvZmqC%GI*8Tt=qAzb?ozs}bveg}fmHI&Wc831d9EB+5t$OUITM z$^uFrl?_WkWyOf2XO1%m}a%sW-MKer;K{KeffyG(h1`vu{=6!CG9O$^`S6MBXqq z3qhqgM;*>VheZZUhBb}MC?Pp7^ObWwAVWvCMp$qcU7EQ#O?PE&?dkEi`BBDaulM6K z8H=*~Vza3fSu+n94$~j#3(w>_yFEwuL@=r+4|sH79oD5S`UaRE>AAtM*jDHhuDMJj zps;r_AhpD`eS!o#BM)}p=~%} zEnpv5J}|GSgIvGGi;3>IjiCPOth0oV_`YE`XTdIH{buPHtgL6Yq0mBXa zeS5$Kvh8l;K`pm*_Y2BN;SJp;ieYNo)55*LglbBs3_NieP)vDmEQ!+wL5opb`XS4` z#-pd;sGL7dQy;Cj=}P5)u%{xg>K~#Laf))kzlAx?J*Q@ha=)k9PaR)7AQ`?`AC;fp zUU=^fP!~`S7!0+2_Q3)GfHmJ%j)J~C>|(aKACi}~&^rt#u~x;I$DIWkwp(aYv_u z#@IVX_ZZ|(rkDb-36($;jL~)RfaQb8mtaq8(hIQUeX#7HcRev7o8E_u)4IEP)Z@$c z%e{|az`HHL1h3^(DPLSn+SK)#<&@WAS4dU~@#5EG^8Quu6<2*drmNHFD z7K&;eY=2Hya2OyCmc98i)&!+$4cH(zt|m=o@98MM9A(Ij9!w^1Bw$h0Y=l0%V`9VI z$&@f4MJ#%RdXX*E#}o@YDARO7L731?QLIZ`nl>sV9^NrSb2RpH=6lXXmejtNf_Hs5 zDQGr3wC+)OB@#=rMjJ|2>N*SFf3ltS==LlH#I*LyPX*p_BCJ+F_L^Gpg(z5N-ZU>ETuGQ9T*eK%dU?vW5RStnji_dxuLTDo^H z>74c^)}2pzr3qvWUF{f7uGVURPy4H%6!~A{0|g1pb%eD5Rv&>af8cwy3BT2V=o8psL7&cm3&4_ak%0b_FTR& z%L-EndjFwW64fDZg2F1^S3n#y8WE-}bD}#iQ{tX$UT#xsL8v;j{IcH6QnW4Xck->P zMhba=m*sLx4tRcOI|KG=K9$eVbp~cw5^Mu-*Z~6CnX#542&b0Qjsb8w{TPy?&BDcs zmydeFpvUL{C<8Va>^=LA^#u(n^K6&?1J7p6Gs}kx`snx5 zMYj56#eH!I)>V2*SuQKV2v9P^z5@O3rwg&*gpim>A|slwGrQCr0wYqxY{z{_rn3TR zKpW=LCv%n{fh^&I){Lb5;P;83C}5M=QW8J|%$8{)-P$j;6 z5sz7(b8-fe5p6#~GjF+a?n%DbiO4FZq-8S4jy5@%y#y!I(HKEEW8`EgnPD#rv9-3r z4#5{W6;a%OR#GCt%S~WJdf`wkW|A!ANQfBUHA4$B4*uU*Igi zpNgzy#*VW*krZF(yh_ssY&O17NAZQ;qQS~OTXreF&^zewTnks}zQC{LMifO_Lt|X~ zViuJVZn@!&Qhnz4V3K3YS`!!%IH+#QmT3$fg%QfuB4=8GO6LTMdILR$6Hydj=u)gp zW{j4}412by(!eNU&=|pT$BC3Xmbrzk0Fw`u&Iv4F972yjPN<`Cf;IGFPKeTdfh(xt z1v9LvbWUL3Hmm@pa{{oeX*mH(X9REp=K7Z=Fe2qzz}&szKGTsnu>w~(f|F7dU+5YK z`~_1nn!t#_;sqA^%y&8pBb32UW?Wb4i~x*{+vTQg8b+w6`GPmCfHErEb;*>UN%Tc; zVXs|IuFFTJMHn<+a3;$8IopSTlFa#j1WU(7yKNXPI|?HNN8lwl@Mr=f(iRyrh{$B0 z{dX`CZOU}(OLP=di0(__YExJeW-`ZKK=oC&jmD?3g0Qg5?E&5;v0@FJOYl;X!U=&A zEo=Z;v5v+HuJJ&uz$I8(l(0mHJxtA_*o=u}j6$A((FM&;B8t~@#lcEAF1pJe#Y#9M z#}MlPY_%#ELwJ%W3iK;1VGmIl$q@y)6!&*o`6;f>rAQ=G6zU2LbLE#flIDp5!ME<; z!j>|1CU}l9=@_Gsux4%Inn{iUkmCN=*50*pObIa!LS435JqSfiQK)$f_UZwpG*1-h z15BM_prLCX7N`xh>Ne1l>$X_h_H2*Di8a}_-0~ULBvx$8YS(O8<=%)5TNE-qByj%* zgMC$^4oM~*0}D|tU;^fa6^RqW69`U*(s=E&{X4u^+EyF@(i2VR0Rjt&$nxQ&gq{Xd zK3|PUOo+&e9yTKTvt?_tqj7>29<;HQsVJOKn+ZO1lE8{!<7FFwqA)_IqJWmW1uMfN zr=dk=#h>bu7bHSZ#Zi9k}By-{z9fNByiolA%X{8lB-=%OulBB^Yf>s za6$p2PSBL|E6k1dA*@YcMBc+@zFlq)aEJlc1@BBG!W9DpLwb`fQ+^oWxHvHAnfDjh z8~{*~i)&V>A_unY6IZ7Okr4&!*R9}I?_lvl0wpOujm zUI;8$f$fVyWJO_j3+KJOmYT*2ei2R1Zeu$VCl)lMM$D%`!c}>i@?wg{3W9Zl{}>Ti z5m0@L`m!4S`{?!)BJX z^jdgW36hb6Y+JVCFqvV$`2?%5HCLdT!U)|8T)8naiolDki>zweV$I8SR93h`<72ic zS=o-riNcX>k#TzkP2q%~v?rpS$jOtFwHX2s_vOR=Y;WJOGwF0seDAm$n+)asbXkSI zUnWEhihfMdL%^!~|0xMFNdE4;cQ6x?b&P(5beT1zO zJR?;^PPD9{bFgxX!U(~+B-G@4-H|x4j6dj<>6}0V#yWgl2Br*d zu`_EDgU$o|T5gJ(mz5-5?0wcW0WnG9#V*?=do~MVlEjP6H|0(QKBs8BptNW-yrd>_ zqEFdFa}Q?^RX`f)iKa6E^K=dQS&MwnW!I!~!kd=eH_CKg0MDiardve~8E@y=rTWtFngcSen8MH6^?A&=f}KBMyKqKXddnPB5$1>=dmCjL7estVuUz#hyYNL{2m- zifo^9i=d9gi2Wh9ZNskqHH8yGBh1sb;O8}yY6|1{ylj+fyS+JbNxaypc(ko{E-4_^ z;@Q#ZhsraD1bKKMFkk!$XR=uUqbG;N-Sa+=77$!swQwpMkW@ro^j73MyXAT`UhuAj zVcWj_;1hXKdK&EhwhWau(UaRUSkALU`4srFB=KVNs?2jM{S> z*qi)5kzp+tDZ`7Y9&^1}!&!XevFmh3U<=2F*4w}i!4qi?6{EaNb(!CY^=9Rx>tvsO z;{-Xel704V>+^0oHH!7tZjNTM&t8G4GxynLvd5mnfw))ZD%E4opkz~D6_xC<<57F& zam!Sf`2?@maQWva&v_UcV`f0Y#*PXdh9 zn=B!cFIKGY-Ey4vg3I@x1~k}Veg5Ywf*0>9!7LBE=G zvd?}Hd*_~|mF@|oRa?8(Oq<|}ycbLcWTMZyTW&<-ca5Ili&SE{$$SBs?6cz(SNZHR z*=KJyFpIBRUqBNWk&r|{0J_}ju=ew;(>;MQ-wMBub+X4^iMl8cqVk)aN%F+-8YgVo zcl*{aE~F)j<_pRP7Cag6-36770kM2;N_Cm9TtC4+kz;K+)|O#ii13aMi-#}KclQ<}$U2X^k$T*liCoQU4vrv8Xdl!Pdr5c)2FDZ|sHCwL+U+(ih#8TSNNAnDZ?uugNOK5^8l9v7)BNIJV7*^LCf2Gu=djc?OiM<=e-XeG+Rk|wD zZJ8gK4qy{q(YXL)k*AzW^_g)uP&7WfO7{ftwZPhkSIHiG3L7e~;#8{7oZn9$vqzsj zPbl3J*x;2=k6os6%=-uUcP02|W$s6}IKS`?E-Jf11t5lD*?teebFj?^t**lHrdfr2yIf+ zFQs!y$)RvUZ_;Yl+C#oe;>1n_KG?%aDGD#NPvLC2vTrh()I?G_;d7BzB`c^Xyiiak zB=Rftg)8A0{S0CviJa(_Sb?2|ElW+}#O~6=_LFeDPJJRLDh;u3(-Mvw*zZb9tY%;# zn)`QfdROq`_+(`61}5mK0*=HFyr3kRVz7gU)fU?4PUfbJmCg%bz~jtrHa?LReN$z% z8%Dw>21GG<=>5CQwmCcWgy<~537R=7yFvIwUKGy#GG1v#V#Q8H^<*!CToNmG)-H2i zOG#mc-jxgc%}|fTie0|DU}Z3!7r@Ayj_KPc@}jV4y?<9e@db(0gs80W6+YODkE*c3 zJ(U%{p8d{>VLC5>URt~eQCOkdG$bS`tk7?5nih5LEPXjLD^4Q{D=8_w&;eGX2VP2& zSTR^)LfvM3)9i?>=*Nsg-|?aykrn;jen-(Eup)opDKT`fg8!aDHXpgF#Fs4p-tp5i zQ+?*s)OTa_NWR#au(D*P`pi!L%~UgN?3p=;<1dpqoB#FX)M8L6R^VB@eD%GaGpwMq zHpLf0zesyK?+|?=oDZbEk`b5u4IX#S{`ogyY9~)xILKA$E znW(q;-e~$H7)33rFZ@TlEg319Y_j9apcqT8$?(YnyW~BZCn$^f!X0%OqV+U}b;b9@ zi4<{WHNZ2w0iMk);>;!fe0J(EP>RX4KJ2Zhkmmw?~XZm0M z;h>{{eHT`d1z$?H}y!2Sg|VYO`bzwL~vmUhUtP4>PU=Ov$0>mu+x2kH);N0ulyVW zE3&SHwbgbhoKR)k-tBZo0K>S$g#XACn?d6Q+qzEkniEqLMhH#?MU}Dz(UCZ@6_})W zDMjIg@Xf81D-2EXg7R2TrQ@@0Aw zBi6#I+I9nVDZUVxn;^s6%opk?z7VV(Q@k;A#q}s8;&quTwoft64=%+Q`V~eRE?+9$ z7kH0nP*D4o<$lHx8PP0#WMnXvW3Eb;8M3>17d%0Sdl^s06 zBQatac$AsfRJt#4m#vvkP%6W0Uq&@keP%jiX0TN{CxC|%a8^`uLU<-YG)}M*pVCKG zOi_5Dh8ssTff31e4{!>zFPVYVpfQ5ma{q}bIhD=`ln-1}l*tTxQ!clgGG`WbJ;@iF ziyQ`JrsHY?BLe3;1(Oq%&I{CRiFFiT=tF)GMfu1L5IuZVKm9zJ<(ydn;(a>!@AgWRfrnhelI{dIm6UWS@Q%oky z%H>$NTY_ho_)jFle+s+ZZFF2L*H2@!FRSv5WQ}t6C)(EPh-mCZ5!!FIcaLWK=1mBw`q~u z2Tu;c5V`(`!3IAp(&XgbbZ*gQipc~vkWXfBQwavk?VV{e!(S$GHvi?;DnXrMGRcFb z@27ifS!E@2?Co;v422$v5qnd%YdAJ@?`g7RMjVE}W@8!XTnZ~>$2GCj83B19#YiXu zC-NW~E<-Y%6Tth@i`JT(eHtTpF1Dh4C>b$L;e@hJ87G0s9D7@c2m7rikHm<*6*&wf z_PpiOSi#*QV@q69IH49!Dsxy@+Rr{RR9<+;OR-G|)&ga28Y>cJu}D)`p>~%FR)z?S$SriV`&&C4ib+du zop>lcF&8Z>lnb^1ZnI`7vWja69f=cz)^B^DyA)Qa5c`ysAp$E>HTPFClnN_YHHjuO z;&-Adp~J1Y((h@E;7nxp3dUT$T-8!C%bwfuT^#}=@`uCmzPDaUX6}Np*FZ4fwRH@k63iFPt%FzR(DlRY`)Q8;K_*L=<}#)&`rW&% zD%D}GvM*)f!m31@)pz7F5^YvoeN9ySUYp;d_(HbVmyu|*zJo51Wj3cuvl-QwCNntq zvRbWAvjwlfBmw4QN1HCyVfLNR%v77%_Zu@3ZB}=n>5@z~>nPqihUbpp+2i-$C$kR* z5B)UB*4FTMdu!+%+sh++d^R|*PqO_ct!8c3SdRxcdHutW6Oq=F*FXPtvR>{c^+x>o zi|NEMznuN>>c?byHUpOA?a5U#dpAWEn}77qpvm*Ib}|1tq% z?%{_Y|MGJX4EBETzt?|BZf`FCKu#WWk}g-96#uQooPo0-`B)jVpk(EI5Bziq!QTn6w?&mM%XN``Nmm-M!JMhQ-lcV$H*Q|x_`Yg@dR;cNcE3jxkg4BYx+|Mh zy|oV7q;*o1O;StNWHz7P%^?G(g3GjOa6pAE{kyVmuCjWEuC=C*YR{2ufCUA6Y~og5 z4B(!9-h*|06@r9POce(&51EA(R^0?4GO0?Vm<*Ihk!LH|BbLRv$nw^<`b*0FWiqa3samwU)<>As(MIjev#;$5EP0e{$q%nydy`<0^+)-UN-WclB5zZ- z1J9bu4)GupFst_V`a@A?>mprUSeKM_DwJ!Jt|7mk+=V1qmiYkdo3hMPYvHC+eAe^4 zv_dP;Z$|0)$tiTBd1me+1EDoHX!hGCFdmc`0G!Prk% zD=V|NiGY-}uKkZ(W|rR@)lZUVj?3GleJ%Vt#W5vGG1-T_ZmoNC_)|0KW>C3J;IcI9 zAAThdncY)o&8oEGU7eIg?F63t6)$R8%hlNdG~KNdO);2nnlyjcH0ECMW}g{Vm zuvYU=!rIxu(R3kuOfU1(&p-afa`VlK2m1hzes%&s{QS#bezXVFbkUl%aH@XyBCDU$ zmF08XU}c*9Uj6Pw{w;m|dYO8~akFpC5?N(64a~;3Ws0RATW-lDxhe8PLc}@|Fs$X} zdQDTp(FF=%X9@>;<&#Vdf{rQi4)Hq!uE3!RXgu!7ieZqyQ?P(fBB2kAtH$65zSHP9 zauFy09l!2p4H!1uuHRL)k-<_f(U6@!fpxQT!V#UO4+2($=9pTi#3co-p&D1DG;*Gr zjvGeu8{6_zH|r{${b}2NWa4j^)@k9v=Gq;I0rL#A(lkdewPv$3GrZY})KqGznxhtRKkE=!w)V9Yz}_l7+=5siDAW5j@jCabjzN$Nza%#5;Bf)NmRZ_V@ zQCB6g%Rg9iJ!Yxt z%yiQyEj#8WYjUzHmJO`+QC)0maJUWYzkg}f&l;x8C359p@qynszhz4VAeL84G*JBu z6pL6xw^-xx=imNCJmNqFTR+$W;hwSGEvRT#X}zqnJuPP-?@JP{lYLb_X1Gd()r449 zC9F_z%ec&O(^9>n60wy%rQM{V?xM}|6^svbEhwV1+=hOQ*6P!=-y5OtOl~-@VEajj zze-=VD~#$Yd0y?LsH1G%?o4GDhlV_2Y+YqxNq_{Z3${TAQWeaVISl6w7X1=dgs@{( z83B7bjJg10XX7qirl8;oGE&!Kof<`-6$^S{ugl3MtCbg;kr_C+Yg5PzNl)n4Y9LR6 z3eXyW#>;e%b?{JOpU@k8JWa2YRZE)(%HqQ$980?5sL`GL``e9cZ ztZ4n5BKF9PiWV>FG_-YIO`L3hr$QNc-ir%;l2>kv1-K&34BlTf0;mdE(*p0V; z8hi9J)ZS(Vj-RlOL8}>bzbuu!dKj%#FL++l#zNCbwcJYm_q7|$J($RrTOfN?c%?@O z_}G|o*y+)1>}Z8UD{4R+z;k=h!g);1Tt(VE*{?}mcPak7HM^R_mUh|5My1+Z4-p$# zcg_Bll$?NAkuI?{)#F;AS#TFu(`TxX?ZnHdaC>w6n*5S@YAYoE{3h}!2rK_hCe z&(esR>pwvwYQ4|Wh+6MUX~fS?)TB;~Mmb`1#s!%?oOwZ-Ho3#NxUG{?t}O`|?c>KR zlu>>m0My9Zf({u*=EztaVl61yj=F#yo|{-Ng~yne8EjK2^|>325~X3+TV-JGtK_~C z&y!w5a#FQm9QnFE1@2)IbuMXaD7NWgQmFwcUS?QSuhhxd^9JPb=5Q}|ej5b~PQ9_M z53FK(NsqAsp!vW@cQ38r>DBb^BvHof+Eg(U#X3(%cBHIW(nEL?xwm+=+KFnZen<}n zZ4iE5Gty(fRJW7w_NL7S&e0xnfd*wbFRfeGCV|I`FP=+u)Oh(kf~u3d+xbA=_$2^# zgNf{M{qVh@=nTy0Eo8X9k;BKpgtVyS1C%UUbhsG+mP1egIX*sF`gOhV_z57oA=dSF zNA+d4vcc(-n)6HcBs0V4q4HwQ*P5*LLd!Z}>XQ7)`ZsAg@{K+?D^AL4l}d+XU%67JemmPn+#WacySf*FKOMo*o z0}|9mq8Ts_3Y>#wI39-A)UV?EBi#(XE_<}9e38t7xe~EmQgo=HgW)c&JKL!IBMocjqcB!ZhUKfH!z!dqh$chFkePxELQo!BUx*i z0$WMyXNBdda%-jfiszrh!uk>O26pNS`t~Z z{GaAj5SYhgpGx-GK2;rlu=~pjeOAvh2R3RWU(sAg4sHLl9Ez&GZ#hQm6o05YMbEdp zRIJ>gu6!!;QVcH;$!qQvj*PI86ss3${yB&h%L8sl5VHnr5BktF(mGgy%^eE5_t`tD zpQF_8u-{Le47dAZv-^Z7FP&ckeaQ^Jf$@v0VCbQ%$*PhaeoUUhHnR9{s$%@qGjqyS z?entw-&MUwWR@RUsY#QQY;q~TG-hzcQh#1gHpf=V&og_-$Z?gb^~JI`+=@qKZ$t}; zW$(X`n2Q70SZdQH^oow}cGlK&R~DIkdkwy}Q@PBF?Z5o3cWTyNorYPBz$Yt%f)1V6 zrlaUdx!afcCd2nV!2gEX2MD}G3~K}98yT!U8f*QaeLj1==x)&8q7o_Z6v-5l^j!}p4-V+vQb zHm%0-G+Ph&U*W3gj0UOK)ZN~G37jTos9Nqi3kPEb^Gb{<-wR~|9cq2*2*hqYc<6EV z83QqhTxt^OrF70=7hztHm7d<6d*e&>;7b2jye&~>eN|@hcH#3g>q`Guq+)LtxX}>! z;%akXk3t4Afh{Oe*K>y3nq~~<=(1dUg9qO2i)3Lg>aBZQ-!*w|K)mCnu#eIkAR4M&dhvp--euImz?QD9J}omY-R`9eW!oS9KBF=Tty zIZm6#KK8Ej4E^3Go08(LC~vl|+_)m|eQUM9wz_^dP~3e?L`zY5$x>_fy+ZFa4L263 zYDDx(Pa$Y}7y->8+0rlmkVcAoU@n=@Z=YQjbfYw)Z|4Q&Nqvw1bPPcVe0~eMcY`f%&$AK{~rHQZ zRDjL%Tlo`aAo)Z;Lfs zdmYsG_)9Z}n<9Sx1Vbvc`(ZfE818#egW03EdU3Hjwm##LouazUABXJN49M_UbRw1; zulQtQq{~e$&nJyki_;R;jsf{fW0cBX{z4(a0bq#L@t&2Y9_cC^?U zkrv9fQ!uR&hcj=)#PL^YJuT9}POi?vWAAjiOULBkYCi3A0H%&69l7&TE=D6VDjk{d zhNs_8uW*osbj1|T?b*A_n>fVTM!oIAm)3{*ySV&RKOW2va?^{;Z+(*jcbUL5Lq9sqNZ7GuZ!bpwqZc&2Gixn1tKz0hfAin(LHNAm-55AZZ!3B z_TAC)L9^FbgxRfUrJL;^#!B->v(ehmu07rB!j&GVs`D&wMje=3b&PJqkd){cn!GE^ zEhmfV@ts=GNHw^ID63Ug2zg3nuaykaafc;JnL8D_B)Gf8+cmOegBQS_X`ce*;g)fd z3z#4uGJlnd@&+|*&$_%y;wYEu4Km(da`;lRQj!oZbZ&@8xx47NK3kR*FEp_4J{Y7`O5kaRhC`9W|#(tw^4UX`xGZ)pa4j~XVBCKL# zzQJkL-QG*u8#UvGiV>SGu4-o+p+cEzJ58BOv&TRIQuhcnP^1mE%>K)Ezf#Guc~{*% zH&2F_dDT;Y)oBc~1FA=4-{rQeJkx$1~+l4C%v7z{FK zkVr}Qr$73zvm9f>3QnVghedikzqqX#(>anZVy4wRFQ0g6MMCLte&s|_GcM=@8K&R` ztfvp2a7oxmwM!4P?&EfuA#n(yH~GUXH#7^5gqcui-661#Do!qUW<2Xk&n!*dSDAy2 zunU-J;nssax+6}M8{R+4btEFINB#j_XlT0XqR-={^;g0G~%KPmH^)kXt?A&U7{ zhYk^m^k%I50B@cHh2~_P9xjXxX(eAgv9pt1L1WHYVJM+wy5Hx@E@|HT-R~z)S+Sz0 z&TYJ&pT#_rvq)B(-s1(AHG|Xk$58HzM#*H=5@yi0PNR;Vj2}l}lviKqw@SgaT$QfS za4Yga;EaI|cMCh$r?OfF6zIs|HoD&@nyY5&Vg$nN1v}(U_Zf|}YztMPfVjw%28iNf z+ksvv@@rqyC#qY|a?RUVN18}-U2Owd>q>5{r>JKAl7m^C8EA4Tqt+h`+D9Qf0lEO} zq3;;YeV@y>%ndZn-7)ipUgN?-<-;s{+`gX_mt|Uvc<#N?*-;FHEW%Wq5TBNIH zXS%KjB0&-@5MTqKB-YIQ_lrknA`{5Og9L3?muBy}EFvF~k&%&+@%+!7|K)F;h*_x5$yaR8tm-ujDu{HhKoE*V)*&Qi~V^p_C`q*!FTx4OD6DF zocp8P8~N!t^KOGEiKk&a_435?W6vLrl4YFl!(fXborhTl-LBJM5okl<;lhu)K^S}R-!NZ! z`OL?igSj7Kge9B#Y2ZP-WSNcvfI3@_W}c6WT4q7I>rK;Sx!6@Lc4-00$j3=)KrY|} zpa&uB&455_2Kx*~i30?Hx_Of@$`MP{gyCPL3BZ~`BbX$a<6h6r%5~sr^_@T9Q(^WnZqC>K-VH#d5C=PVHU&% zc!=$B5QX>)|V zt#(j0-n;cP*pbreN3cuyryn)0Tg|G2G6?bR#;%P3bHlZkO?hw%6T+0f3! zqja^XIg15+3KRj~Jh)Di`*0kj9q1d!Nic%yhnE9y6r_1LLHq^Y99ZBq zmd*POH8NzLOU%2lutnG8i-orktv7^VQDTdWMI?A@m)q(g zxb^&^D<65H47@v;0n|dFCS@qn(F|_j@de0TUF9fW^z}mMT!>S*Bt*dh4#qWr=<~Wr zG@YD3!tWqF!o*3N12n*C`AFZqhhrOzZ~f67${-1zreG8hz>_qYlO!mH_gJE<1Gfwc zLzu-~S>DOuBXPQEkVx6l8~eF0K;UalJ6;hmw&kLZurj%o#(mwH6`Qxcx@AGEjFw}( zA=EKgBtSzUp?R#X=QN3G`J)LO0sJmXZfV21!itoB3!T+9ftw7hn{Zdim-s_i3snJu z1PI3I#uE_`?6e+BEM{Z?;4;qg)L*p1$VD6yFM_=S!4+hfJOR?Ep#g?TfLD2cw}Mc; zyDg_Cl!JOvI1h94(BNaa7PR6uUO;ye`RROZ5Pj?|o-uJEhNR!3|>{xXwD)fP`&S3`49TM1f+DAO^L_d>Mze zdK!dG1B4(u1MYGYb$W6GapuS|; z3I?%3Z`U0(j){MrMu8u`%stm~lZl5J7 zTS+dTBGYI%o)$n9fP-)v(*wN=S0lJG*%PImF>0sr7cW`n(*$pCz9*$fSr1(S1p@{o zF}eP;oxZh_dwE{GR!3J{Y*)4OVbumnf} z;f6$50*>AWYY?FY5(Y8OKo6Zn_rY4X7>lsnpDB^VThJxKRo{GMwaFzk0}|{zodP8HLwaE3Y{r72>vc2BR*Llb|<^F`Mg>B%a1sYNA_BGV#3=#hK+ z>1M#kDGNr+6iw5!z#rE>qX;Sm-%I?Tf#}>wh-TmSNq1!eJ-mda2DW$()}>nkq_UvY z!%nj*7%u6C>vT^biiL58??-xk)=w&?p=mGXe&=nyxH`E;rGK7`lE}8Prj)x&Dmajj z#1pUB_L_|)xER9tinLy9ze>t_vqJpmH%bi<#?%DOAJ@Rw9}Rp7^%t^)H2B*REChg; zFd0=WcYA*q$?nf2HB=GKcR@AT@P&^D5A;RhgOovAR zn1R~6ET*&o5W7hy454jjQyeHyMk}H=_J^tirkLAdd1CTse$mQCsd1*_*oni2wo8O@ z;saJmMbKm`EKhHP>E&SI&xQG*B4^u)u=TJ*(*m*aXsDv=9mvlqJQAheqnBZS@}p(2 z@m}xU<1k8g`JuX=l#=uRLiJ&$}KHY;@Out+fFLs-~qIvl)I z5t1$}u*x3}U#6RZ+kshuMFNQmvlu&cJ{NS}o6&CtclaBq?r5-y~$s9HciC=V<6<02+v7_c&+yG55tiExzh7)n^CjRj(f zvq_LP%F9()N+1qrum^e6m9H~^g~-mHSco^d!l)vF%^@!5ulOWu{GCP?>#D*2~ugCOxUI_*0Ii~@-|E$G9ONJwS zIfBSH7cOWZXQU~>IfH*jO>|!XVt^*DsI{QeE=#a11j>Vl?RZVqIK}D(xsmY#pJLE)1z0wTq=~Z)6<;3Dr+wnlJr`SZEip z?ztbcX9g#o`f>OxZr6Ie(*T9w`^cVzm%_KE3w+WEQTpXb=YU{AoJvIuwZdH)4g&5I z^3ziiV>?|maPgzt4v4`tf{=uD$7VMm`kV|zI38I7I9ii7gMh~ipQ;yUp5VnrY)3O2 zH((&Bu9vs4mTuZ3P=R76r7~hgS7Czlo+E_UKVGAY>EPwn#nt%>H%tWt1Q5~G_=>5q zqYjcNd|WaSwm0pYQ&*vRDgFzHN3Wdb7rAA?&CIe&;%D0{1}v_!kng5KTI7$-)L^s8 zcJ;b50x64WGQ-i{&(L3mUz3HaF6m}7icbV|`n6BY!V_;0pc7hW>)JAk_HuaN0;t#@ zFgXq$kt`Ge10>Sh6aUGEBcb!p+0y5RPe7$XxVGk{0&1g^mOi0?pkice>s>FrDK4&I z+Bi1FGXHj&1-lL}DQO)c(i?H#I*5{&QdIH#t8YQ=W2}1uKjx~Bt6RC2r^BfO%8{iC7f)V62!W&=`u1S+H0*GF62#$fo&`>bc zaKujvmk=PL2&_l|>3$lw^E4?zsGvTJv)gDb54Crf(#oN{$A2mJ3M{ zUt1!?dLVE%hxG$LU$1^$FO+~fk{!#xP0;b~UYw9|kV}gQkW5(TWm^EC;JI0Lll!#& zs44=@O{|CGMj0~juXPDqurM8}e3oL|cr+$aGg#sCQt5VcwDz{-4OLeNX_={8m^9Snwx-soNU9>41OW>`jfxF>!H zVo*sYF{{-nNH5HihyoQ=ULzt?vNP4e$RIhcS+dkAT?U{ey z6)x;`@>8w%G<*Z7@|7MakN%Cd@{xc>Le|kW2D7PD9b-65p`|0TobzmB8g}7^GN>sa3RLok zAH0G2ZqTvMP2d{VGD6sfC`CA0#^AROU&)pMF10uhOK+8S#@6?pN@$ajxzl zaI!EuYDuNMD-|XBgU5|^qpktUP|H9^fwkI@WJLfxm`UoY+e!WOR{8`&^|-<}v^F;W z>Afda#t)usQ;0RyNi;R)N+16s7ETxe<&e=)LO=ZA6)iAx8pq*e_8~r^GzT(Di=krC z)H2?+4{v7a4WbF~%rI#_BJvQAvkQO&Be?l`vDR)xSD5^_c*29JaAw$O0y(jY@p6hNg%_~s@DxfT5 z;hf~yatmIXlw_6(=QPD z3D&cYfA^z@E1FH?_r;6t*tj(>nRArE8nKuGMaB za;@5WwNHcU?%geWse7Duxka6$R8oN!KNPx?_Gc6NEPb6)_=lSM1IE#mZmIh5#Ht20 z-RqWAtf2b9YiiaBclL?29H%l&p(rw?HmgUT-+c08NX55DES`u6S0WJIe z5*+2$?L=gi9*u;>JzR@aYg(I-))@a6D^}Mb8aw#Tyuyc1co2_c%6erTfj{!RHbQL<=t$!V=y zs)4r1y%?@gib<`YIMTLr~rBwcP zDhhL2`%A{9NhuGmp<_)wMh!IWDlXWE>{1<}>GH>|J0Bk%A0K`X%KxL|H@Y+h2s!lj zJn`Kdd^p+T7EJ_Tj(?N+&arO>C+)}mrKl3Xc*yYa)dFdy9%k8wIBR)@njKoyerO!2 zTZx9+;hgmpt|^bpCy}Z9Ch)WNtF`tmmuhG`n4{9e4OJcJHi+ocx@bi0V5NhEA1K0N8cRHnOw__GPVvmnQu55^UiO!CrT+D~f? zI1J_s7IBIZ_21SQ5}!=vA@$$Z81iGV1X)90b@9tO!(puoZ7lp#=Y6*BYtUCQGglH3 zZwyy;6U&H|K60o&4IE|#!bYP;AuE{uY|z(PFO!zs8>=lG!Wo03#a;{|NZIF z;j1^^^Wos)#~0RFc?Rld_btu0zWp?iN?>h zW141x!TG5^j`+Lv0H5x4rTnL#KGbx^wp!PB%Q)6mY4o>?_8rq-gE{ba85`;l`HO21 z*}`-P3+D?{LHltae{v0^dg*kt0Htd-3m2w$zxvHdH>!=U)y1r($GWS_$s87fI>6kwq^RIHud2?D_=;m%Z zsJ`n+@~l|5sKa2|w$`k^!+>SH?UoNkhq3q!*~q!WAjJu=QB8+|3PP*!zz(Abo@qZ0 zUB=PQP=&X57)RU%wxW>EzMaZ0TKYR`BSwA(55c-zlGU*+ooWg#TKbnt2cATspSA7B zjf>9jsoG-O-lDZAJSa2Co`A9}>pvLmB*+er-s;Tte6YvAlwnh#3@m}NFpjAh#&N95 zVB0vqlos28Xslq>mu$2R(!Ro?a}0YO#Pdg4fwRpRMdMQED?cC2I*q_R8f!5+e6aP3 zie;zlmO~hB+*adli-9Z#U;H^wqidDxu+2DT2O7i(m2V!xjI4K7nyhv-%Qu!%yEbJI zh&6X5<1nAZNxYgTOXC#2^D{$>Mt^&ym=`O6*oJ%S!vXg+{J8iBZnb1ajMPH z+o4N`raEwkF$5&FwKMJA8wy_5b=A|F6@Q;*_nrD<`_d2yli%SEz#+5;*Wjn-`3h?| zx*=)SaLwh(T8gtebaQ3QFA^tJA0kz*oLTP%`SK?}x(ilc$s5vuwOd5cH@KQVwxgn= z5NE}Iwz;##<+kFv(L74o)1y)p)Y(y%_tcVqbTIaPU4N$jT)o_9Q)E5)`#GYR?CAV) zH1p$WtBcBPUsDRUZh#hrTHW1?)}mMHw@28bSPX2Ogn6vQju7iAleI_SwZ6Nhq!(fBuT#>0ZdK+Zwuo&aD?M!pm z6)kmjG;4U4s)+XU1Sa`hL+5aK?Suva5c0g1p=+Vb+|!%u)7t*j-q?uZ=hkQ`2HLei z*J+sIeIkCe7Fzw{xo0ZCRBiipO&0>D8*VZmR*EWpF{$5~hB)RCL2!$ICFB2k@5mE@317F)L+-%O5U8>EiWr&o&!B zYo6d!D*4W)&vO2?DC%76sWeywBTV8qVvnVwQ^)1~(xUFOb6Ibu8-Ps4eV2cF`y&#(UVg>_z<m#p1n#42=8}=&6+(Y2c-#Y-j&Y@5TVc`|X4hP0`vC|gl?Ar%FA>sI zt=Kw3$C|?KG1`~^b&t`qPOp1_mW6fQ1GKDw>mH!7QmvzFQ-#@@&K(NE){IiE+sg82 zd&{HQUK^sV-b7cnS;G69N2n$Qs4YM19HxDtSl1BN60co!tfdIH#wxM)5zIu%dkc{+mazrU}5``-!9%zkteAk5<>;TtRARm#+1wdw6w@lKE|jg_gL;h;_K? zqPm3C>ocZWc>TI_{ZhtXOO2>ClwNzSwm;yOPUXQ`9`)*D*->xUIe=LinExCGj~&Ez zYOP1#JW@^arE@lHAr+^Z0!J0B`3Wa6^EMQNdQ@hKs>5hCZoK=VPc<(^8sxA-+YF_Y za!oT%!rB>V2uWY1rMBG)9XYbRF}*}rYik3Bm!h~{z~fYA)+TAz1Bjp64_Q_K*giF5 z$2#C{75GjgsfWF*B6jTxHxpX>~S|LZJg>4VpHBlvnpS`W1Er( zj8vk$k(u@vT{lgC5rG8n!Oy&GNy%Zbyz)vG1+uANg@0pF1jC5uOHw~wz2_2iHrOUq z?#s(X(=b}?!tDb$0#)8>PK97Z`uQ=Su6eSBY^o+h#cR6>e-ZmsHtn_8<*GSw*R(jc z9K-0`(RwT4HxAV`wPp8PZrhj7WVNz z!ts~|)j?zVyR*ZQtHY6_!z)*ZR~FbUAZ7A*>tZb+6&=j2i3ucQV`2u!99cAcD3OJ1 zT&0ckWo6`GX&d=`X`v2iYNZa<_{iS)$ZTAuVrXfDv`odanPs$BmS)DDT|}1UgpqwY zS3!k1=Yfql2Y#8@Gv7k&XUWIa=v6i1$)k`bFUF5X^OJezZtmkpqxoREICM78@T1ZE zed@cLPw=DG{Qvs#IMDT|{Db$2D!zGz!*P+2%&&62pM5Z{hMtxA$@WL?_DALRmdz}> zSoairmFceNQYF8ieJg(yU0iJPXWx2mL@(Fz(Rv-#_Btx}a;(UDpk(_acl*-#4&Ey| zxmmE$^QfU`Wlk$|EqXe5tkLtRq32Nx38kfQAcPchqiQ2ya6_%r7M*L2U>eT!VGXVBZ*3!RiQ6IkCw#l`-Hq}~+H?4E2_~XdyZ+o%bc8oV+S16UH5Q!>?Pi++ zO6pMYTR3XlJCt>+Dg~Na^sm-*a>Yor9;_T%A-=S$uOeG=H>$fvA)glx8@RI=NE7UbH0?|%&EpmX@&-ur-(i+UgYY-X)I>;TM|fmZLH<8(Q?OOkb_ z5@>DbF8@mzU8`<*UsdqE8v4_YV_*+8%vqe>MqQJQofwI2_%F+Z+Su4e*FUF`SQ#Kb77VSsuU2t&?8MQt{VrqFd|Jpz#VObBB>wh zM-k2R$nIopWF6u^>qntR8gZ63t{r(*cH1#e=g}CtUFT+Y9#GF_V%^rxBWhuG_6_Ph zqS{z1<#ZlS7M8P|s?KBaQ8a&VZOg3oQA45l*(KX^wT~L=GMaY|>uD9=)F!-108kBT zs(xs<$kJePsO#0QNn6U|wyNum88^`nyT?J-$zlu_(jdC2ztO%AQ?M*AVkJh|AA_G6T|u!h?9W0d)>*xvR7=$uy4b^G21 zZ|%rds~pvo4I90Y6027r#i1b#ZntRedRq*{Z*mX9Iu0f40t1q_^ho%iELjnDU0j9e9B& znA^*iw|jmuV4aOr^bm1?rH)m|bwI0W%-yf*3P`_H7v4Ilw;c-nz-p%s2hi+5gJ1#7 zE};VB;PEUOEk$ztB47ZWE5^l#(#$xE*;g0HfVtR*6<^jJm_A^Ryr2SV9z+3##;?3w ze0L4Z{S5~+tzdLno|7LvAHRBmL%hS$E#tUm`Iv~p#+*>iF`hKxUZa;b$*Ee0aI~Y8l?>uOCaTYK(4oh{xX9)yd5% zhKs;AEXA2}a3yEAw$EbLpealpcu)JHs}&NNk_Br9u((h9S8B%^TlT` zv{tvr(QN}6Ss=1JO;#tW9BJVfOCMzYOwWgylB3$pJZ|gdJz*sJcrb|8(VJ z2zKnp<&d690(30roENP;d}+FhnBtU{fek|%{M0Zjed#u7by)p^N4(chDKd0)n6Wab znFbqG4`4EAm=)Tg)s2!0b(z~bzOlLU;3kNJ2P0lsPD^#;^_uZ1H{~k1z~b#sX`(0k zc4bXIU#b{aotNsfVa?h!$!U3;PH5DrvCL-_kZCiSF`y6?95mg0$2$*$`_^eUsP(#P zyjRv3yL2yEE|b#)*VQUO$l298aQjdn_x)z)f$c`DFiy)Q)N-V9>9i`PwH(N#&Ry3D zX*pW;U|EH@cB7RAzpB{QVH_#vN$G-MOk0j1TNmAR;iTmlraV(~fwvpae)X%5IojbX zf$&Xlu*XFbvxnb1AFPv;iT=1MK6D?Ooe$T-QCVM2Kzyf!8A7PrvEt7cYm=JpaKDsj_|W7>t(g zrw31aU5y^R5z%rgFcnA5WE3LZpN@dKVptxdRGQFun7R{O}Ix(s3M$~9iQ3?O=#!*tMIRr~NzZ7+K5e#d`O0fn~x zxN*_BgY&J~z8Iq1zsVAkrzRKXA6(v`#T25Wp>IPY3cBN&x;FlmvZH}4(>$_1j-hp< z{)Wn}<%qJYVRcL*v+kDorFk^jRlgUa#Mc*1e>acB-E5t51T2}VSpG5kJFh+;rB(`eD)bMH?!-9C5L zi$YtDv0|8VeiuGpdLi5lRZPJ>`ye*}B~NGJT)m8pvbyl67)9Rf6(VVQkV}MRM|PL7 zv>mdnsmn-Z9;H!kmtiEWTMuTJfr`Uyqo7VBNusOLP?uqf{5%!z*ku^SP@M<4%V;J8 zaPrqqLmGTpe(K;#iG>98gnv_qlRl5jWe2p2YMd-{BY}CGCGPH`y*9!hlO;+lmBPhi zulQmes#>#HC7jmkB`$*48!Ge9b4)mTxCEoiUa)LX0W z9n-g97Zc-YC2`Bicy74p(cdAK!p)Pk|1>W@2e)T_n@UTfq3qN$`>$+C-Tp0zlUcWv zjg>C{4I@p$AY!eg@GE#HfLRz$pyME;$PppY7=Oa0fF(rs$l{@W@sbG`Z387w-onVc z-ZBd&%ZNnQnV+IuSA>kA_{xhY79*cJ6H$Pw_$3BOjw4_5bQ!=}mWwf^#sbpGWlU?B zX-TF{uz#Lm?)?;C3^UATMX)keKFd^6X&w4~?*xp3aC|(_Z5m%N`;%s?TzR)DE%knN zQMZN6s9i961 z;Y0SYcOPaUI^FE0^C)?c`hpCE&os+lz(Le-mNC+TzhQ-P?u4UzezceY zE63`Cm~HNMMLTanPrRJp(ru!)d0B|f^4(Hh1pFw@I3dP7w8)c;RUTmbDt;=g7PtqP zJA&Lo#aBM%%!6-jj#ATM_E$GxUb4?J3G&g5&oLND{Za0ri)_Xmq=%V_`t4KCld&Xo zb$mR5q7@(89su|m^TOHz7=hI-4|WA0yLhFM`wNH+^W=UD7(v32_Twr&jFKp+IVAL% zEF+{KL1qEKc&CGb_{7`}cyRFOkAa0?JmJlc@02E`k>xP}E$`b+1ci~n!Iu{j;!(65 zgOcLp9(3&fZ5WA&@bbMI!l7U^t9_S16IsC7U*h3RJYO3L+l-cx@~0_59{~G-U-3U5 zrPkC2&$c8SxdKzVQS16vB^w3crczCq{ltQS8y>Oel%v3$JewuUXiP}q0~w6>y^Cp_ zAk{w1Koy{`7&l?!M_I7{b!0CIc3Zhia;2VyE;kroM&MGr_uCe>%Db~2NlVW1wWKT< z2lS!;hAC32@Cz1paq{tmjV!++?+PjL6b8U+7bAfW8Y00gl83nH(S|7xB^0eLm9lJT zzhQQKvQ5||M~y4lMak0cZz4y!&tnT2a`4l&eFpB}Eqnk8$(yeFjGPbf?8se#!xt0` zA0?@x%Q|mV7Hi+9LGW&wt?Zyt#u=P*0?l6DLOZxcm@K7J=;nxlInd84Ym%@X0>xJm zt2deaGyM$A?B37ofq*&pXtxWBMT+p_6(eJp{-X};1Ip@>4TA`vkOurW3!=%|^8ZN` zt@i{_kXCjLF8}!=!Uf4mK0U;{UKu@f$%xalzc&0ZbQ|~)Y`FqKZ0fuL8-y#b$|S+2 z4xfT_ji(G2_PI?Ss~o96*>BEMd>aZa0Zdz&N}#7Nk&1a$piuHW*q`ouf8N2`Y>$85 zfeZW!G}S1eF5~cTV2<~}Ry6f+1oWFBW1=!0?dGfVt(PeNbOJXOn@b1EE=7wugRdw>C%GR{tcHc%4e_JLW8;~mkh?-A zah|ts&=?Gk;L*I|O@KZsP(<7xEO7)ZNj*Wac&pVJ~p6Be{p#K11_%^ z`P%;&r~V|zC?qV}wFPiH;Is^IJ_7`keiOd%Xku+W!nuap+&r_VUJoaPUoL<5O8^Yzfj^uVqvf1e@jK+1s zn>WH15=_ZA4A4Oa5%;DJ*WH?MwS6oqK|`DKam_g!-bfn#RY(%-@Ej>a3=UK8$N5M1Hn~zXyhEw)#019O6s|h-D6=~TkLyfzQ-}X@G z^|BS*n&!&|J;#I{C<^)q+J4}rY^v+q3y|gO@Q*&oPiF~m8wB{zJ2we%uh;Lal+pFw z=T_I&t7%Ilp&@b^-^HMf=wC})3|JC}0hGHCZWxs90LFa9$EiSM8Z3Y)?B>WSRO;*u zu|*q&u^0+q2=Bx365lw`f-?-OtiR?dyp59EcCT%0DaAbbc1`^UkB0ZSFMYS`RCpez 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 Ssq4~y_WuQW3Z(gZj|>1~`)~jN diff --git a/resources/schema/schema.json.sha256 b/resources/schema/schema.json.sha256 index 959acc96..bc65d190 100644 --- a/resources/schema/schema.json.sha256 +++ b/resources/schema/schema.json.sha256 @@ -1 +1 @@ -YT3bugHVH3b13x2txy17kankEO0OqL9os_sojzqXlxo \ No newline at end of file +nGrZtt6AUdU1bcCirQQzKiHbnluseipQ1zi4wqAu0AY \ No newline at end of file diff --git a/tests/Cargo.toml b/tests/Cargo.toml index 77394eeb..356d7c46 100644 --- a/tests/Cargo.toml +++ b/tests/Cargo.toml @@ -81,7 +81,7 @@ rkyv = { version = "0.8.10", features = ["little_endian"] } compact_str = "0.9.0" quick-xml = "0.39" jmap-tools = { version = "0.1" } -dns-update = { version = "0.3", features = ["test_provider"] } +dns-update = { version = "0.4.0", features = ["test_provider"] } x509-parser = "0.18" [target.'cfg(not(target_env = "msvc"))'.dependencies] diff --git a/tests/src/automation/acme.rs b/tests/src/automation/acme.rs index b1c007dc..562b68b3 100644 --- a/tests/src/automation/acme.rs +++ b/tests/src/automation/acme.rs @@ -139,9 +139,8 @@ pub async fn test(test: &TestServer) { // Create test Pebble and In Memory DNS servers let pebble_dns_id = account .registry_create_object(DnsServer::Cloudflare(DnsServerCloudflare { - email: "test@pebble.org".to_string().into(), secret: SecretKey::Value(SecretKeyValue { - secret: "secret".into(), + secret: "test@pebble.org".into(), }), description: "Pebble DNS server".to_string(), ..Default::default() @@ -149,9 +148,8 @@ pub async fn test(test: &TestServer) { .await; let in_memory_dns_id = account .registry_create_object(DnsServer::Cloudflare(DnsServerCloudflare { - email: "test@memory.org".to_string().into(), secret: SecretKey::Value(SecretKeyValue { - secret: "secret".into(), + secret: "test@memory.org".into(), }), description: "In-memory DNS server".to_string(), ..Default::default() diff --git a/tests/src/automation/dkim.rs b/tests/src/automation/dkim.rs index 9d9d7813..b7257873 100644 --- a/tests/src/automation/dkim.rs +++ b/tests/src/automation/dkim.rs @@ -30,9 +30,8 @@ pub async fn test(test: &TestServer) { // Create test In Memory DNS servers let dns_server_id = account .registry_create_object(DnsServer::Cloudflare(DnsServerCloudflare { - email: "test@memory.org".to_string().into(), secret: SecretKey::Value(SecretKeyValue { - secret: "secret".into(), + secret: "test@memory.org".into(), }), description: "In-memory DNS server".to_string(), ..Default::default() diff --git a/tests/src/automation/dns.rs b/tests/src/automation/dns.rs index 22056549..41b4be98 100644 --- a/tests/src/automation/dns.rs +++ b/tests/src/automation/dns.rs @@ -87,9 +87,8 @@ pub async fn test(test: &TestServer) { // Create test In Memory DNS servers let dns_server_id = account .registry_create_object(DnsServer::Cloudflare(DnsServerCloudflare { - email: "test@memory.org".to_string().into(), secret: SecretKey::Value(SecretKeyValue { - secret: "secret".into(), + secret: "test@memory.org".into(), }), description: "In-memory DNS server".to_string(), ..Default::default()