foundation_deployment_cloudflare 0.1.1

//! Auto-generated API module for cloudflare dns.
//!
//! Generated by `cargo run --bin ewe_platform gen_api`.
//! DO NOT EDIT MANUALLY.
//!
//! Feature flag: `cloudflare_dns `

#![cfg(feature = "cloudflare_dns")]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
#![allow(clippy::missing_errors_doc, clippy::doc_markdown, clippy::useless_format)]
#![allow(unused_imports)]

use foundation_netio::{DynNetClient, PreparedRequestBuilder};
use foundation_netio::shared::client::http_client::HttpClient;
use serde::{Deserialize, Serialize};
use foundation_macros::JsonHash;

// Import shared types used by this module
use super::shared::AccessResponseCollectionHostnames;
use super::shared::AccessApiResponseCollection;
use super::shared::AccessApiResponseCommon;
use super::shared::AccessSettings;
use super::shared::TunnelApiResponseCommon;
use super::shared::TunnelCreatedAt;
use super::shared::TunnelDeletedAt;

use super::shared::ApiResponse;

// =============================================================================
// TYPE DECLARATIONS
// =============================================================================

/// `AccessMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlsAccountRegionalHostnamesAccountListRegionsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlsAccountRegionalHostnamesAccountListRegionsResponse {
    /// `result` property.
    pub result: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
}

/// `DlsApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlsApiResponseCollection {
    /// `result_info` property.
    pub result_info: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DlsApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlsApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DlsMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlsMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlsRegionKey` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlsRegionKey {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DnsAnalyticsApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsApiResponseSingle {
}

/// `DnsAnalyticsData` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsData {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsFilters` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsFilters {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsLimit` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsLimit {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsQuery` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsQuery {
    /// dimensions property.
    pub dimensions: Vec<String>,
    /// filters property.
    pub filters: Option<DnsAnalyticsFilters>,
    /// limit property.
    pub limit: DnsAnalyticsLimit,
    /// metrics property.
    pub metrics: Vec<String>,
    /// since property.
    pub since: DnsAnalyticsSince,
    /// sort property.
    pub sort: Option<Vec<String>>,
    /// until property.
    pub until: DnsAnalyticsUntil,
}

/// `DnsAnalyticsReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsReport {
    /// `data` property.
    pub data: Vec<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsAnalyticsReportBytime` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsReportBytime {
    /// `data` property.
    pub data: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// `query` property.
    pub query: std::collections::HashMap<String, serde_json::Value>,
    /// `time_intervals` property.
    pub time_intervals: Vec<Vec<String>>,
}

/// `DnsAnalyticsResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsResult {
    /// data property.
    pub data: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// data_lag property.
    pub data_lag: f64,
    /// max property.
    pub max: serde_json::Value,
    /// min property.
    pub min: serde_json::Value,
    /// query property.
    pub query: DnsAnalyticsQuery,
    /// rows property.
    pub rows: f64,
    /// totals property.
    pub totals: serde_json::Value,
}

/// `DnsAnalyticsSince` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsSince {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsTimeDelta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsTimeDelta {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsAnalyticsUntil` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsAnalyticsUntil {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsCustomNameserversAcnsResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversAcnsResponseCollection {
    /// `result` property.
    pub result: Option<Vec<DnsCustomNameserversCustomNS>>,
}

/// `DnsCustomNameserversAcnsResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversAcnsResponseSingle {
    /// `result` property.
    pub result: Option<DnsCustomNameserversCustomNS>,
}

/// `DnsCustomNameserversApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversApiResponseCollection {
    /// `result_info` property.
    pub result_info: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsCustomNameserversApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DnsCustomNameserversApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversApiResponseSingle {
}

/// `DnsCustomNameserversCustomNS` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversCustomNS {
    /// dns_records property.
    pub dns_records: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// ns_name property.
    pub ns_name: DnsCustomNameserversNsName,
    /// ns_set property.
    pub ns_set: Option<DnsCustomNameserversNsSet>,
    /// status property.
    pub status: String,
    /// zone_tag property.
    pub zone_tag: DnsCustomNameserversSchemasIdentifier,
}

/// `DnsCustomNameserversCustomNSInput` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversCustomNSInput {
    /// ns_name property.
    pub ns_name: DnsCustomNameserversNsName,
    /// ns_set property.
    pub ns_set: Option<DnsCustomNameserversNsSet>,
}

/// `DnsCustomNameserversEmptyResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversEmptyResponse {
    /// `result` property.
    pub result: Option<Vec<String>>,
}

/// `DnsCustomNameserversMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsCustomNameserversNsName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversNsName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsCustomNameserversNsSet` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversNsSet {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsCustomNameserversSchemasIdentifier` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsCustomNameserversSchemasIdentifier {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallAnalyticsByTimeResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallAnalyticsByTimeResponse {
    /// `result` property.
    pub result: Option<DnsAnalyticsReportBytime>,
}

/// `DnsFirewallAnalyticsTableResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallAnalyticsTableResponse {
    /// `result` property.
    pub result: Option<DnsAnalyticsReport>,
}

/// `DnsFirewallApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallApiResponseCollection {
    /// `result_info` property.
    pub result_info: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsFirewallApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DnsFirewallApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallApiResponseSingle {
}

/// `DnsFirewallAttackMitigation` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallAttackMitigation {
    /// enabled property.
    pub enabled: Option<bool>,
    /// only_when_upstream_unhealthy property.
    pub only_when_upstream_unhealthy: Option<bool>,
}

/// `DnsFirewallDeleteDnsFirewallClusterResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDeleteDnsFirewallClusterResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsFirewallDeprecateAnyRequests` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDeprecateAnyRequests {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallDnsFirewallCluster` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallCluster {
    /// attack_mitigation property.
    pub attack_mitigation: Option<DnsFirewallAttackMitigation>,
    /// deprecate_any_requests property.
    pub deprecate_any_requests: Option<DnsFirewallDeprecateAnyRequests>,
    /// ecs_fallback property.
    pub ecs_fallback: Option<DnsFirewallEcsFallback>,
    /// maximum_cache_ttl property.
    pub maximum_cache_ttl: Option<DnsFirewallMaximumCacheTtl>,
    /// minimum_cache_ttl property.
    pub minimum_cache_ttl: Option<DnsFirewallMinimumCacheTtl>,
    /// name property.
    pub name: Option<DnsFirewallName>,
    /// negative_cache_ttl property.
    pub negative_cache_ttl: Option<DnsFirewallNegativeCacheTtl>,
    /// ratelimit property.
    pub ratelimit: Option<DnsFirewallRatelimit>,
    /// retries property.
    pub retries: Option<DnsFirewallRetries>,
    /// upstream_ips property.
    pub upstream_ips: Option<Vec<String>>,
}

/// `DnsFirewallDnsFirewallClusterPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallClusterPatch {
}

/// `DnsFirewallDnsFirewallClusterPost` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallClusterPost {
}

/// `DnsFirewallDnsFirewallClusterResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallClusterResponse {
    /// `dns_firewall_ips` property.
    pub dns_firewall_ips: Vec<String>,
    /// `id` property.
    pub id: DnsFirewallIdentifier,
    /// `modified_on` property.
    pub modified_on: DnsFirewallModifiedOn,
}

/// `DnsFirewallDnsFirewallIps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallIps {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallDnsFirewallResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallResponseCollection {
    /// `result` property.
    pub result: Option<Vec<DnsFirewallDnsFirewallClusterResponse>>,
}

/// `DnsFirewallDnsFirewallReverseDns` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallReverseDns {
    /// ptr property.
    pub ptr: Option<serde_json::Value>,
}

/// `DnsFirewallDnsFirewallReverseDnsPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallReverseDnsPatch {
}

/// `DnsFirewallDnsFirewallReverseDnsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallReverseDnsResponse {
    /// `result` property.
    pub result: Option<Box<DnsFirewallDnsFirewallReverseDnsResponse>>,
}

/// `DnsFirewallDnsFirewallSingleResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallDnsFirewallSingleResponse {
    /// `result` property.
    pub result: Option<DnsFirewallDnsFirewallClusterResponse>,
}

/// `DnsFirewallEcsFallback` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallEcsFallback {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallIdentifier` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallIdentifier {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallMaximumCacheTtl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallMaximumCacheTtl {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallMinimumCacheTtl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallMinimumCacheTtl {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallModifiedOn` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallModifiedOn {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallNegativeCacheTtl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallNegativeCacheTtl {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallRatelimit` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallRatelimit {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallRetries` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallRetries {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsFirewallUpstreamIps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsFirewallUpstreamIps {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsRecordsApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsRecordsApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DnsRecordsApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsRecordsApiResponseSingle {
}

/// `DnsRecordsDnsResponseAccountUsage` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsRecordsDnsResponseAccountUsage {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsRecordsMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsRecordsMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsAccountSettings` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsAccountSettings {
    /// zone_defaults property.
    pub zone_defaults: DnsSettingsDnsSettingsAccountResponse,
}

/// `DnsSettingsAccountSettingsPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsAccountSettingsPatch {
    /// zone_defaults property.
    pub zone_defaults: Option<DnsSettingsDnsSettingsAccountPatch>,
}

/// `DnsSettingsApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsApiResponseCollection {
    /// `result_info` property.
    pub result_info: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsSettingsApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DnsSettingsApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsApiResponseSingle {
}

/// `DnsSettingsCreatedTime` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsCreatedTime {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsDnsResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsResponseSingle {
    /// `result` property.
    pub result: Option<DnsSettingsAccountSettings>,
}

/// `DnsSettingsDnsSettingsAccountPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsSettingsAccountPatch {
    /// `nameservers` property.
    pub nameservers: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `DnsSettingsDnsSettingsAccountResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsSettingsAccountResponse {
    /// `nameservers` property.
    pub nameservers: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsDnsSettingsBase` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsSettingsBase {
    /// flatten_all_cnames property.
    pub flatten_all_cnames: Option<DnsSettingsFlattenAllCnames>,
    /// foundation_dns property.
    pub foundation_dns: Option<DnsSettingsFoundationDns>,
    /// internal_dns property.
    pub internal_dns: Option<DnsSettingsInternalDnsBase>,
    /// multi_provider property.
    pub multi_provider: Option<DnsSettingsMultiProvider>,
    /// ns_ttl property.
    pub ns_ttl: Option<DnsSettingsNsTtl>,
    /// secondary_overrides property.
    pub secondary_overrides: Option<DnsSettingsSecondaryOverrides>,
    /// soa property.
    pub soa: Option<DnsSettingsSoaBase>,
    /// zone_mode property.
    pub zone_mode: Option<DnsSettingsZoneMode>,
}

/// `DnsSettingsDnsSettingsPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsSettingsPatch {
}

/// `DnsSettingsDnsSettingsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsSettingsResponse {
    /// `internal_dns` property.
    pub internal_dns: DnsSettingsInternalDnsResponse,
    /// `soa` property.
    pub soa: DnsSettingsSoaResponse,
}

/// `DnsSettingsDnsView` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsView {
    /// created_time property.
    pub created_time: Option<DnsSettingsCreatedTime>,
    /// modified_time property.
    pub modified_time: Option<DnsSettingsModifiedTime>,
    /// name property.
    pub name: Option<DnsSettingsName>,
    /// zones property.
    pub zones: Option<Vec<String>>,
}

/// `DnsSettingsDnsViewPatch` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsViewPatch {
}

/// `DnsSettingsDnsViewPost` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsViewPost {
}

/// `DnsSettingsDnsViewResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsViewResponse {
    /// `id` property.
    pub id: DnsSettingsIdentifier,
}

/// `DnsSettingsDnsViewResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsViewResponseCollection {
    /// `result` property.
    pub result: Option<Vec<DnsSettingsDnsViewResponse>>,
}

/// `DnsSettingsDnsViewResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsDnsViewResponseSingle {
    /// `result` property.
    pub result: Option<DnsSettingsDnsViewResponse>,
}

/// `DnsSettingsFlattenAllCnames` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsFlattenAllCnames {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsFoundationDns` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsFoundationDns {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsIdentifier` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsIdentifier {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsInternalDnsBase` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsInternalDnsBase {
    /// reference_zone_id property.
    pub reference_zone_id: Option<String>,
}

/// `DnsSettingsInternalDnsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsInternalDnsResponse {
}

/// `DnsSettingsMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsModifiedTime` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsModifiedTime {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsMultiProvider` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsMultiProvider {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsNsTtl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsNsTtl {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsSecondaryOverrides` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsSecondaryOverrides {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsSoaBase` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsSoaBase {
    /// expire property.
    pub expire: Option<f64>,
    /// min_ttl property.
    pub min_ttl: Option<f64>,
    /// mname property.
    pub mname: Option<String>,
    /// refresh property.
    pub refresh: Option<f64>,
    /// retry property.
    pub retry: Option<f64>,
    /// rname property.
    pub rname: Option<String>,
    /// ttl property.
    pub ttl: Option<f64>,
}

/// `DnsSettingsSoaResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsSoaResponse {
}

/// `DnsSettingsZoneMode` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsZoneMode {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsSettingsZones` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsSettingsZones {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DnsViewsForAnAccountDeleteInternalDnsViewResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsViewsForAnAccountDeleteInternalDnsViewResponse {
    /// result property.
    pub result: Option<DnsViewsForAnAccountDeleteInternalDnsViewResponseResult>,
}

/// `DnsViewsForAnAccountDeleteInternalDnsViewResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DnsViewsForAnAccountDeleteInternalDnsViewResponseResult {
    /// id property.
    pub id: Option<DnsSettingsIdentifier>,
}

/// `RadarGetDnsSummaryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponse {
    /// result property.
    pub result: RadarGetDnsSummaryResponseResult,
    /// success property.
    pub success: bool,
}

/// `RadarGetDnsSummaryResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResult {
    /// meta property.
    pub meta: RadarGetDnsSummaryResponseResultMeta,
    /// summary_0 property.
    pub summary_0: serde_json::Value,
}

/// `RadarGetDnsSummaryResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResultMeta {
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetDnsSummaryResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetDnsSummaryResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetDnsSummaryResponseResultMetaUnitsItem>,
}

/// `RadarGetDnsSummaryResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetDnsSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetDnsSummaryResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetDnsSummaryResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

/// `RadarGetDnsSummaryResponseResultMetaUnitsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsSummaryResponseResultMetaUnitsItem {
    /// name property.
    pub name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTimeseriesGroupResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponse {
    /// result property.
    pub result: RadarGetDnsTimeseriesGroupResponseResult,
    /// success property.
    pub success: bool,
}

/// `RadarGetDnsTimeseriesGroupResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResult {
    /// meta property.
    pub meta: RadarGetDnsTimeseriesGroupResponseResultMeta,
    /// serie_0 property.
    pub serie_0: RadarGetDnsTimeseriesGroupResponseResultSerie0,
}

/// `RadarGetDnsTimeseriesGroupResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultMeta {
    /// aggInterval property.
    #[serde(rename = "aggInterval")]
    pub agg_interval: String,
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetDnsTimeseriesGroupResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetDnsTimeseriesGroupResponseResultMetaUnitsItem>,
}

/// `RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetDnsTimeseriesGroupResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

/// `RadarGetDnsTimeseriesGroupResponseResultMetaUnitsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultMetaUnitsItem {
    /// name property.
    pub name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTimeseriesGroupResponseResultSerie0` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupResponseResultSerie0 {
    /// timestamps property.
    pub timestamps: Vec<String>,
}

/// `RadarGetDnsTimeseriesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponse {
    /// result property.
    pub result: RadarGetDnsTimeseriesResponseResult,
    /// success property.
    pub success: bool,
}

/// `RadarGetDnsTimeseriesResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResult {
    /// meta property.
    pub meta: RadarGetDnsTimeseriesResponseResultMeta,
}

/// `RadarGetDnsTimeseriesResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResultMeta {
    /// aggInterval property.
    #[serde(rename = "aggInterval")]
    pub agg_interval: String,
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetDnsTimeseriesResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetDnsTimeseriesResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetDnsTimeseriesResponseResultMetaUnitsItem>,
}

/// `RadarGetDnsTimeseriesResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetDnsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetDnsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetDnsTimeseriesResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

/// `RadarGetDnsTimeseriesResponseResultMetaUnitsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTimeseriesResponseResultMetaUnitsItem {
    /// name property.
    pub name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTopAsesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponse {
    /// result property.
    pub result: RadarGetDnsTopAsesResponseResult,
    /// success property.
    pub success: bool,
}

/// `RadarGetDnsTopAsesResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResult {
    /// meta property.
    pub meta: RadarGetDnsTopAsesResponseResultMeta,
    /// top_0 property.
    pub top_0: Vec<RadarGetDnsTopAsesResponseResultTop0Item>,
}

/// `RadarGetDnsTopAsesResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultMeta {
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: Option<RadarGetDnsTopAsesResponseResultMetaConfidenceInfo>,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetDnsTopAsesResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetDnsTopAsesResponseResultMetaUnitsItem>,
}

/// `RadarGetDnsTopAsesResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetDnsTopAsesResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetDnsTopAsesResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetDnsTopAsesResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

/// `RadarGetDnsTopAsesResponseResultMetaUnitsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultMetaUnitsItem {
    /// name property.
    pub name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTopAsesResponseResultTop0Item` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopAsesResponseResultTop0Item {
    /// clientASN property.
    #[serde(rename = "clientASN")]
    pub client_asn: i64,
    /// clientASName property.
    #[serde(rename = "clientASName")]
    pub client_as_name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTopLocationsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponse {
    /// result property.
    pub result: RadarGetDnsTopLocationsResponseResult,
    /// success property.
    pub success: bool,
}

/// `RadarGetDnsTopLocationsResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResult {
    /// meta property.
    pub meta: RadarGetDnsTopLocationsResponseResultMeta,
    /// top_0 property.
    pub top_0: Vec<RadarGetDnsTopLocationsResponseResultTop0Item>,
}

/// `RadarGetDnsTopLocationsResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultMeta {
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: Option<RadarGetDnsTopLocationsResponseResultMetaConfidenceInfo>,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetDnsTopLocationsResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetDnsTopLocationsResponseResultMetaUnitsItem>,
}

/// `RadarGetDnsTopLocationsResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetDnsTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetDnsTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetDnsTopLocationsResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

/// `RadarGetDnsTopLocationsResponseResultMetaUnitsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultMetaUnitsItem {
    /// name property.
    pub name: String,
    /// value property.
    pub value: String,
}

/// `RadarGetDnsTopLocationsResponseResultTop0Item` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsTopLocationsResponseResultTop0Item {
    /// clientCountryAlpha2 property.
    #[serde(rename = "clientCountryAlpha2")]
    pub client_country_alpha2: String,
    /// clientCountryName property.
    #[serde(rename = "clientCountryName")]
    pub client_country_name: String,
    /// value property.
    pub value: String,
}

/// `SecondaryDnsAcl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsAcl {
    /// id property.
    pub id: SecondaryDnsComponentsSchemasIdentifier,
    /// ip_range property.
    pub ip_range: SecondaryDnsIpRange,
    /// name property.
    pub name: SecondaryDnsAclComponentsSchemasName,
}

/// `SecondaryDnsAclComponentsSchemasName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsAclComponentsSchemasName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsAclCreateAclRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsAclCreateAclRequest {
    /// ip_range property.
    pub ip_range: SecondaryDnsIpRange,
    /// name property.
    pub name: SecondaryDnsAclComponentsSchemasName,
}

/// `SecondaryDnsAlgo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsAlgo {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsApiResponseCollection {
    /// `result_info` property.
    pub result_info: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `SecondaryDnsApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `SecondaryDnsApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsApiResponseSingle {
}

/// `SecondaryDnsComponentsSchemasIdResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsComponentsSchemasIdResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `SecondaryDnsComponentsSchemasIdentifier` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsComponentsSchemasIdentifier {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsComponentsSchemasName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsComponentsSchemasName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsComponentsSchemasResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsComponentsSchemasResponseCollection {
    /// `result` property.
    pub result: Option<Vec<SecondaryDnsAcl>>,
}

/// `SecondaryDnsComponentsSchemasSingleResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsComponentsSchemasSingleResponse {
    /// `result` property.
    pub result: Option<SecondaryDnsAcl>,
}

/// `SecondaryDnsIp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsIp {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsIpRange` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsIpRange {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsIxfrEnable` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsIxfrEnable {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsPeer` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsPeer {
    /// id property.
    pub id: SecondaryDnsComponentsSchemasIdentifier,
    /// ip property.
    pub ip: Option<SecondaryDnsIp>,
    /// ixfr_enable property.
    pub ixfr_enable: Option<SecondaryDnsIxfrEnable>,
    /// name property.
    pub name: SecondaryDnsComponentsSchemasName,
    /// port property.
    pub port: Option<SecondaryDnsPort>,
    /// tsig_id property.
    pub tsig_id: Option<SecondaryDnsTsigId>,
}

/// `SecondaryDnsPeerCreatePeerRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsPeerCreatePeerRequest {
    /// name property.
    pub name: SecondaryDnsComponentsSchemasName,
}

/// `SecondaryDnsPort` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsPort {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsResponseCollection {
    /// `result` property.
    pub result: Option<Vec<SecondaryDnsTsig>>,
}

/// `SecondaryDnsSchemasIdResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSchemasIdResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `SecondaryDnsSchemasIdentifier` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSchemasIdentifier {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsSchemasName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSchemasName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsSchemasResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSchemasResponseCollection {
    /// `result` property.
    pub result: Option<Vec<SecondaryDnsPeer>>,
}

/// `SecondaryDnsSchemasSingleResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSchemasSingleResponse {
    /// `result` property.
    pub result: Option<SecondaryDnsPeer>,
}

/// `SecondaryDnsSecret` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSecret {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `SecondaryDnsSingleResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsSingleResponse {
    /// `result` property.
    pub result: Option<SecondaryDnsTsig>,
}

/// `SecondaryDnsTsig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsTsig {
    /// algo property.
    pub algo: SecondaryDnsAlgo,
    /// id property.
    pub id: SecondaryDnsSchemasIdentifier,
    /// name property.
    pub name: SecondaryDnsSchemasName,
    /// secret property.
    pub secret: SecondaryDnsSecret,
}

/// `SecondaryDnsTsigId` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct SecondaryDnsTsigId {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelApiResponseCollection {
    /// `result` property.
    pub result: Option<Vec<serde_json::Value>>,
    /// `result_info` property.
    pub result_info: Option<TunnelResultInfo>,
}

/// `TunnelComponentsSchemasTunnelId` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelComponentsSchemasTunnelId {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelHostname` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostname {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelHostnameComment` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostnameComment {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelHostnameRoute` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostnameRoute {
    /// comment property.
    pub comment: Option<TunnelHostnameComment>,
    /// created_at property.
    pub created_at: Option<TunnelCreatedAt>,
    /// deleted_at property.
    pub deleted_at: Option<TunnelDeletedAt>,
    /// hostname property.
    pub hostname: Option<TunnelHostname>,
    /// id property.
    pub id: Option<TunnelHostnameRouteId>,
    /// tunnel_id property.
    pub tunnel_id: Option<TunnelComponentsSchemasTunnelId>,
    /// tunnel_name property.
    pub tunnel_name: Option<TunnelSchemasTunnelName>,
}

/// `TunnelHostnameRouteId` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostnameRouteId {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelHostnameRouteResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostnameRouteResponseCollection {
    /// `result` property.
    pub result: Option<Vec<TunnelHostnameRoute>>,
}

/// `TunnelHostnameRouteResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelHostnameRouteResponseSingle {
    /// `result` property.
    pub result: Option<TunnelHostnameRoute>,
}

/// `TunnelMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `TunnelResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelResultInfo {
    /// count property.
    pub count: Option<f64>,
    /// page property.
    pub page: Option<f64>,
    /// per_page property.
    pub per_page: Option<f64>,
    /// total_count property.
    pub total_count: Option<f64>,
}

/// `TunnelSchemasTunnelName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct TunnelSchemasTunnelName {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `ZeroTrustNetworksRouteHostnameCreateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameCreateRequest {
    /// comment property.
    pub comment: Option<TunnelHostnameComment>,
    /// hostname property.
    pub hostname: Option<TunnelHostname>,
    /// tunnel_id property.
    pub tunnel_id: Option<TunnelComponentsSchemasTunnelId>,
}

/// `ZeroTrustNetworksRouteHostnameUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameUpdateRequest {
    /// comment property.
    pub comment: Option<TunnelHostnameComment>,
    /// hostname property.
    pub hostname: Option<TunnelHostname>,
    /// tunnel_id property.
    pub tunnel_id: Option<TunnelComponentsSchemasTunnelId>,
}

// =============================================================================
// ARGS TYPES (per-endpoint)
// =============================================================================

/// Arguments for [`access-mtls-authentication-list-mtls-certificates-hostname-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationListMtlsCertificatesHostnameSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dls-account-regional-hostnames-account-list-regions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlsAccountRegionalHostnamesAccountListRegionsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-level-custom-nameservers-list-account-custom-nameservers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLevelCustomNameserversListAccountCustomNameserversArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-level-custom-nameservers-add-account-custom-nameserver_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLevelCustomNameserversAddAccountCustomNameserverArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsCustomNameserversCustomNSInput,
}

/// Arguments for [`account-level-custom-nameservers-delete-account-custom-nameserver_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLevelCustomNameserversDeleteAccountCustomNameserverArgs {
    /// Path parameter: `custom_ns_id`.
    pub custom_ns_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-firewall-list-dns-firewall-clusters_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallListDnsFirewallClustersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`dns-firewall-create-dns-firewall-cluster_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallCreateDnsFirewallClusterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsFirewallDnsFirewallClusterPost,
}

/// Arguments for [`dns-firewall-dns-firewall-cluster-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallDnsFirewallClusterDetailsArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-firewall-update-dns-firewall-cluster_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallUpdateDnsFirewallClusterArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsFirewallDnsFirewallClusterPatch,
}

/// Arguments for [`dns-firewall-delete-dns-firewall-cluster_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallDeleteDnsFirewallClusterArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-firewall-analytics-table_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallAnalyticsTableArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `metrics`.
    pub metrics: Option<String>,
    /// Query parameter: `dimensions`.
    pub dimensions: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `until`.
    pub until: Option<String>,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `sort`.
    pub sort: Option<String>,
    /// Query parameter: `filters`.
    pub filters: Option<String>,
}

/// Arguments for [`dns-firewall-analytics-by-time_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallAnalyticsByTimeArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `metrics`.
    pub metrics: Option<String>,
    /// Query parameter: `dimensions`.
    pub dimensions: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `until`.
    pub until: Option<String>,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `sort`.
    pub sort: Option<String>,
    /// Query parameter: `filters`.
    pub filters: Option<String>,
    /// Query parameter: `time_delta`.
    pub time_delta: Option<String>,
}

/// Arguments for [`dns-firewall-show-dns-firewall-cluster-reverse-dns_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallShowDnsFirewallClusterReverseDnsArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-firewall-update-dns-firewall-cluster-reverse-dns_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsFirewallUpdateDnsFirewallClusterReverseDnsArgs {
    /// Path parameter: `dns_firewall_id`.
    pub dns_firewall_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsFirewallDnsFirewallReverseDnsPatch,
}

/// Arguments for [`dns-records-for-an-account-get-usage_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsRecordsForAnAccountGetUsageArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-settings-for-an-account-list-dns-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsSettingsForAnAccountListDnsSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dns-settings-for-an-account-update-dns-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsSettingsForAnAccountUpdateDnsSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsSettingsAccountSettingsPatch,
}

/// Arguments for [`dns-views-for-an-account-list-internal-dns-views_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsViewsForAnAccountListInternalDnsViewsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `name.exact`.
    pub name_exact: Option<String>,
    /// Query parameter: `name.contains`.
    pub name_contains: Option<String>,
    /// Query parameter: `name.startswith`.
    pub name_startswith: Option<String>,
    /// Query parameter: `name.endswith`.
    pub name_endswith: Option<String>,
    /// Query parameter: `zone_id`.
    pub zone_id: Option<String>,
    /// Query parameter: `zone_name`.
    pub zone_name: Option<String>,
    /// Query parameter: `match`.
    pub r#match: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

/// Arguments for [`dns-views-for-an-account-create-internal-dns-views_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsViewsForAnAccountCreateInternalDnsViewsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DnsSettingsDnsViewPost,
}

/// Arguments for [`dns-views-for-an-account-get-internal-dns-view_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsViewsForAnAccountGetInternalDnsViewArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `view_id`.
    pub view_id: String,
}

/// Arguments for [`dns-views-for-an-account-update-internal-dns-view_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsViewsForAnAccountUpdateInternalDnsViewArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `view_id`.
    pub view_id: String,
    /// Request body.
    pub body: DnsSettingsDnsViewPatch,
}

/// Arguments for [`dns-views-for-an-account-delete-internal-dns-view_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DnsViewsForAnAccountDeleteInternalDnsViewArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `view_id`.
    pub view_id: String,
}

/// Arguments for [`secondary-dns-(-acl)-list-ac-ls_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsAclListAcLsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-acl)-create-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsAclCreateAclArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsAclCreateAclRequest,
}

/// Arguments for [`secondary-dns-(-acl)-acl-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsAclAclDetailsArgs {
    /// Path parameter: `acl_id`.
    pub acl_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-acl)-update-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsAclUpdateAclArgs {
    /// Path parameter: `acl_id`.
    pub acl_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsAcl,
}

/// Arguments for [`secondary-dns-(-acl)-delete-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsAclDeleteAclArgs {
    /// Path parameter: `acl_id`.
    pub acl_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-peer)-list-peers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsPeerListPeersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-peer)-create-peer_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsPeerCreatePeerArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsPeerCreatePeerRequest,
}

/// Arguments for [`secondary-dns-(-peer)-peer-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsPeerPeerDetailsArgs {
    /// Path parameter: `peer_id`.
    pub peer_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-peer)-update-peer_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsPeerUpdatePeerArgs {
    /// Path parameter: `peer_id`.
    pub peer_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsPeer,
}

/// Arguments for [`secondary-dns-(-peer)-delete-peer_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsPeerDeletePeerArgs {
    /// Path parameter: `peer_id`.
    pub peer_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-tsig)-list-tsi-gs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsTsigListTsiGsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-tsig)-create-tsig_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsTsigCreateTsigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsTsig,
}

/// Arguments for [`secondary-dns-(-tsig)-tsig-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsTsigTsigDetailsArgs {
    /// Path parameter: `tsig_id`.
    pub tsig_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`secondary-dns-(-tsig)-update-tsig_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsTsigUpdateTsigArgs {
    /// Path parameter: `tsig_id`.
    pub tsig_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: SecondaryDnsTsig,
}

/// Arguments for [`secondary-dns-(-tsig)-delete-tsig_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct SecondaryDnsTsigDeleteTsigArgs {
    /// Path parameter: `tsig_id`.
    pub tsig_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-networks-route-hostname-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `hostname`.
    pub hostname: Option<String>,
    /// Query parameter: `tunnel_id`.
    pub tunnel_id: Option<String>,
    /// Query parameter: `comment`.
    pub comment: Option<String>,
    /// Query parameter: `existed_at`.
    pub existed_at: Option<String>,
    /// Query parameter: `is_deleted`.
    pub is_deleted: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
}

/// Arguments for [`zero-trust-networks-route-hostname-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustNetworksRouteHostnameCreateRequest,
}

/// Arguments for [`zero-trust-networks-route-hostname-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `hostname_route_id`.
    pub hostname_route_id: String,
}

/// Arguments for [`zero-trust-networks-route-hostname-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `hostname_route_id`.
    pub hostname_route_id: String,
    /// Request body.
    pub body: ZeroTrustNetworksRouteHostnameUpdateRequest,
}

/// Arguments for [`zero-trust-networks-route-hostname-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustNetworksRouteHostnameDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `hostname_route_id`.
    pub hostname_route_id: String,
}

/// Arguments for [`radar-get-dns-summary_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsSummaryArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `asn`.
    pub asn: Option<String>,
    /// Query parameter: `location`.
    pub location: Option<String>,
    /// Query parameter: `continent`.
    pub continent: Option<String>,
    /// Query parameter: `cacheHit`.
    pub cache_hit: Option<String>,
    /// Query parameter: `nodata`.
    pub nodata: Option<String>,
    /// Query parameter: `protocol`.
    pub protocol: Option<String>,
    /// Query parameter: `queryType`.
    pub query_type: Option<String>,
    /// Query parameter: `responseCode`.
    pub response_code: Option<String>,
    /// Query parameter: `responseTtl`.
    pub response_ttl: Option<String>,
    /// Query parameter: `dnssec`.
    pub dnssec: Option<String>,
    /// Query parameter: `dnssecAware`.
    pub dnssec_aware: Option<String>,
    /// Query parameter: `dnssecE2e`.
    pub dnssec_e2e: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `matchingAnswer`.
    pub matching_answer: Option<String>,
    /// Query parameter: `tld`.
    pub tld: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-dns-timeseries_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsTimeseriesArgs {
    /// Query parameter: `aggInterval`.
    pub agg_interval: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `asn`.
    pub asn: Option<String>,
    /// Query parameter: `location`.
    pub location: Option<String>,
    /// Query parameter: `continent`.
    pub continent: Option<String>,
    /// Query parameter: `cacheHit`.
    pub cache_hit: Option<String>,
    /// Query parameter: `nodata`.
    pub nodata: Option<String>,
    /// Query parameter: `protocol`.
    pub protocol: Option<String>,
    /// Query parameter: `queryType`.
    pub query_type: Option<String>,
    /// Query parameter: `responseCode`.
    pub response_code: Option<String>,
    /// Query parameter: `responseTtl`.
    pub response_ttl: Option<String>,
    /// Query parameter: `dnssec`.
    pub dnssec: Option<String>,
    /// Query parameter: `dnssecAware`.
    pub dnssec_aware: Option<String>,
    /// Query parameter: `dnssecE2e`.
    pub dnssec_e2e: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `matchingAnswer`.
    pub matching_answer: Option<String>,
    /// Query parameter: `tld`.
    pub tld: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-dns-timeseries-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsTimeseriesGroupArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `aggInterval`.
    pub agg_interval: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `asn`.
    pub asn: Option<String>,
    /// Query parameter: `location`.
    pub location: Option<String>,
    /// Query parameter: `continent`.
    pub continent: Option<String>,
    /// Query parameter: `cacheHit`.
    pub cache_hit: Option<String>,
    /// Query parameter: `nodata`.
    pub nodata: Option<String>,
    /// Query parameter: `protocol`.
    pub protocol: Option<String>,
    /// Query parameter: `queryType`.
    pub query_type: Option<String>,
    /// Query parameter: `responseCode`.
    pub response_code: Option<String>,
    /// Query parameter: `responseTtl`.
    pub response_ttl: Option<String>,
    /// Query parameter: `dnssec`.
    pub dnssec: Option<String>,
    /// Query parameter: `dnssecAware`.
    pub dnssec_aware: Option<String>,
    /// Query parameter: `dnssecE2e`.
    pub dnssec_e2e: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `matchingAnswer`.
    pub matching_answer: Option<String>,
    /// Query parameter: `tld`.
    pub tld: Option<String>,
    /// Query parameter: `normalization`.
    pub normalization: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-dns-top-ases_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsTopAsesArgs {
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `asn`.
    pub asn: Option<String>,
    /// Query parameter: `location`.
    pub location: Option<String>,
    /// Query parameter: `continent`.
    pub continent: Option<String>,
    /// Query parameter: `domain`.
    pub domain: Option<String>,
    /// Query parameter: `cacheHit`.
    pub cache_hit: Option<String>,
    /// Query parameter: `nodata`.
    pub nodata: Option<String>,
    /// Query parameter: `protocol`.
    pub protocol: Option<String>,
    /// Query parameter: `queryType`.
    pub query_type: Option<String>,
    /// Query parameter: `responseCode`.
    pub response_code: Option<String>,
    /// Query parameter: `responseTtl`.
    pub response_ttl: Option<String>,
    /// Query parameter: `dnssec`.
    pub dnssec: Option<String>,
    /// Query parameter: `dnssecAware`.
    pub dnssec_aware: Option<String>,
    /// Query parameter: `dnssecE2e`.
    pub dnssec_e2e: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `matchingAnswer`.
    pub matching_answer: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-dns-top-locations_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsTopLocationsArgs {
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `asn`.
    pub asn: Option<String>,
    /// Query parameter: `location`.
    pub location: Option<String>,
    /// Query parameter: `continent`.
    pub continent: Option<String>,
    /// Query parameter: `domain`.
    pub domain: Option<String>,
    /// Query parameter: `cacheHit`.
    pub cache_hit: Option<String>,
    /// Query parameter: `nodata`.
    pub nodata: Option<String>,
    /// Query parameter: `protocol`.
    pub protocol: Option<String>,
    /// Query parameter: `queryType`.
    pub query_type: Option<String>,
    /// Query parameter: `responseCode`.
    pub response_code: Option<String>,
    /// Query parameter: `responseTtl`.
    pub response_ttl: Option<String>,
    /// Query parameter: `dnssec`.
    pub dnssec: Option<String>,
    /// Query parameter: `dnssecAware`.
    pub dnssec_aware: Option<String>,
    /// Query parameter: `dnssecE2e`.
    pub dnssec_e2e: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `matchingAnswer`.
    pub matching_answer: Option<String>,
    /// Query parameter: `tld`.
    pub tld: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

// =============================================================================
// CLIENT FUNCTIONS (per-endpoint)
// =============================================================================

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/access/certificates/settings
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/access/certificates/settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = access_mtls_authentication_list_mtls_certificates_hostname_settings_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_mtls_authentication_list_mtls_certificates_hostname_settings_request<F>(
    client: DynNetClient,
    args: &AccessMtlsAuthenticationListMtlsCertificatesHostnameSettingsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessResponseCollectionHostnames>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/certificates/settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessResponseCollectionHostnames = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/regional_hostnames/regions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/addressing/regional_hostnames/regions.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dls_account_regional_hostnames_account_list_regions_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dls_account_regional_hostnames_account_list_regions_request<F>(
    client: DynNetClient,
    args: &DlsAccountRegionalHostnamesAccountListRegionsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlsAccountRegionalHostnamesAccountListRegionsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/addressing/regional_hostnames/regions",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlsAccountRegionalHostnamesAccountListRegionsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/custom_ns
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/custom_ns.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = account_level_custom_nameservers_list_account_custom_nameservers_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_level_custom_nameservers_list_account_custom_nameservers_request<F>(
    client: DynNetClient,
    args: &AccountLevelCustomNameserversListAccountCustomNameserversArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsCustomNameserversAcnsResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/custom_ns",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsCustomNameserversAcnsResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/custom_ns
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/custom_ns.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = account_level_custom_nameservers_add_account_custom_nameserver_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_level_custom_nameservers_add_account_custom_nameserver_request<F>(
    client: DynNetClient,
    args: &AccountLevelCustomNameserversAddAccountCustomNameserverArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsCustomNameserversAcnsResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/custom_ns",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsCustomNameserversAcnsResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/custom_ns/{custom_ns_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/custom_ns/{custom_ns_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = account_level_custom_nameservers_delete_account_custom_nameserver_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_level_custom_nameservers_delete_account_custom_nameserver_request<F>(
    client: DynNetClient,
    args: &AccountLevelCustomNameserversDeleteAccountCustomNameserverArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsCustomNameserversEmptyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/custom_ns/{}",
        args.account_id,
        args.custom_ns_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsCustomNameserversEmptyResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_firewall
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_firewall.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_list_dns_firewall_clusters_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_list_dns_firewall_clusters_request<F>(
    client: DynNetClient,
    args: &DnsFirewallListDnsFirewallClustersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dns_firewall
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dns_firewall.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_create_dns_firewall_cluster_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_create_dns_firewall_cluster_request<F>(
    client: DynNetClient,
    args: &DnsFirewallCreateDnsFirewallClusterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_dns_firewall_cluster_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_dns_firewall_cluster_details_request<F>(
    client: DynNetClient,
    args: &DnsFirewallDnsFirewallClusterDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/dns_firewall/{dns_firewall_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/dns_firewall/{dns_firewall_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_update_dns_firewall_cluster_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_update_dns_firewall_cluster_request<F>(
    client: DynNetClient,
    args: &DnsFirewallUpdateDnsFirewallClusterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dns_firewall/{dns_firewall_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dns_firewall/{dns_firewall_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_delete_dns_firewall_cluster_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_delete_dns_firewall_cluster_request<F>(
    client: DynNetClient,
    args: &DnsFirewallDeleteDnsFirewallClusterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDeleteDnsFirewallClusterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDeleteDnsFirewallClusterResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/dns_analytics/report
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/dns_analytics/report.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_analytics_table_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_analytics_table_request<F>(
    client: DynNetClient,
    args: &DnsFirewallAnalyticsTableArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallAnalyticsTableResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}/dns_analytics/report",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("metrics", args.metrics.as_deref());
    builder = builder.query("dimensions", args.dimensions.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("until", args.until.as_deref());
    builder = builder.query("limit", args.limit.as_deref());
    builder = builder.query("sort", args.sort.as_deref());
    builder = builder.query("filters", args.filters.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallAnalyticsTableResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/dns_analytics/report/bytime
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/dns_analytics/report/bytime.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_analytics_by_time_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_analytics_by_time_request<F>(
    client: DynNetClient,
    args: &DnsFirewallAnalyticsByTimeArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallAnalyticsByTimeResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}/dns_analytics/report/bytime",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("metrics", args.metrics.as_deref());
    builder = builder.query("dimensions", args.dimensions.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("until", args.until.as_deref());
    builder = builder.query("limit", args.limit.as_deref());
    builder = builder.query("sort", args.sort.as_deref());
    builder = builder.query("filters", args.filters.as_deref());
    builder = builder.query("time_delta", args.time_delta.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallAnalyticsByTimeResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/reverse_dns
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_firewall/{dns_firewall_id}/reverse_dns.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_show_dns_firewall_cluster_reverse_dns_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_show_dns_firewall_cluster_reverse_dns_request<F>(
    client: DynNetClient,
    args: &DnsFirewallShowDnsFirewallClusterReverseDnsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallReverseDnsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}/reverse_dns",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallReverseDnsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/dns_firewall/{dns_firewall_id}/reverse_dns
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/dns_firewall/{dns_firewall_id}/reverse_dns.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_firewall_update_dns_firewall_cluster_reverse_dns_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_firewall_update_dns_firewall_cluster_reverse_dns_request<F>(
    client: DynNetClient,
    args: &DnsFirewallUpdateDnsFirewallClusterReverseDnsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsFirewallDnsFirewallReverseDnsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_firewall/{}/reverse_dns",
        args.account_id,
        args.dns_firewall_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsFirewallDnsFirewallReverseDnsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_records/usage
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_records/usage.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_records_for_an_account_get_usage_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_records_for_an_account_get_usage_request<F>(
    client: DynNetClient,
    args: &DnsRecordsForAnAccountGetUsageArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsRecordsDnsResponseAccountUsage>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_records/usage",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsRecordsDnsResponseAccountUsage = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_settings
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_settings_for_an_account_list_dns_settings_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_settings_for_an_account_list_dns_settings_request<F>(
    client: DynNetClient,
    args: &DnsSettingsForAnAccountListDnsSettingsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/dns_settings
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/dns_settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_settings_for_an_account_update_dns_settings_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_settings_for_an_account_update_dns_settings_request<F>(
    client: DynNetClient,
    args: &DnsSettingsForAnAccountUpdateDnsSettingsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_settings/views
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_settings/views.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_views_for_an_account_list_internal_dns_views_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_views_for_an_account_list_internal_dns_views_request<F>(
    client: DynNetClient,
    args: &DnsViewsForAnAccountListInternalDnsViewsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsViewResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings/views",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("name.exact", args.name_exact.as_deref());
    builder = builder.query("name.contains", args.name_contains.as_deref());
    builder = builder.query("name.startswith", args.name_startswith.as_deref());
    builder = builder.query("name.endswith", args.name_endswith.as_deref());
    builder = builder.query("zone_id", args.zone_id.as_deref());
    builder = builder.query("zone_name", args.zone_name.as_deref());
    builder = builder.query("match", args.r#match.as_deref());
    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsViewResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dns_settings/views
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dns_settings/views.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_views_for_an_account_create_internal_dns_views_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_views_for_an_account_create_internal_dns_views_request<F>(
    client: DynNetClient,
    args: &DnsViewsForAnAccountCreateInternalDnsViewsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsViewResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings/views",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsViewResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dns_settings/views/{view_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dns_settings/views/{view_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_views_for_an_account_get_internal_dns_view_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_views_for_an_account_get_internal_dns_view_request<F>(
    client: DynNetClient,
    args: &DnsViewsForAnAccountGetInternalDnsViewArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsViewResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings/views/{}",
        args.account_id,
        args.view_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsViewResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/dns_settings/views/{view_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/dns_settings/views/{view_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_views_for_an_account_update_internal_dns_view_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_views_for_an_account_update_internal_dns_view_request<F>(
    client: DynNetClient,
    args: &DnsViewsForAnAccountUpdateInternalDnsViewArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsSettingsDnsViewResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings/views/{}",
        args.account_id,
        args.view_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsSettingsDnsViewResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dns_settings/views/{view_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dns_settings/views/{view_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dns_views_for_an_account_delete_internal_dns_view_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dns_views_for_an_account_delete_internal_dns_view_request<F>(
    client: DynNetClient,
    args: &DnsViewsForAnAccountDeleteInternalDnsViewArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DnsViewsForAnAccountDeleteInternalDnsViewResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dns_settings/views/{}",
        args.account_id,
        args.view_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DnsViewsForAnAccountDeleteInternalDnsViewResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/acls
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/acls.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_acl_list_ac_ls_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_acl_list_ac_ls_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsAclListAcLsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/acls",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/secondary_dns/acls
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/secondary_dns/acls.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_acl_create_acl_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_acl_create_acl_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsAclCreateAclArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/acls",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/acls/{acl_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/acls/{acl_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_acl_acl_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_acl_acl_details_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsAclAclDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/acls/{}",
        args.account_id,
        args.acl_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/secondary_dns/acls/{acl_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/secondary_dns/acls/{acl_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_acl_update_acl_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_acl_update_acl_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsAclUpdateAclArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/acls/{}",
        args.account_id,
        args.acl_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/secondary_dns/acls/{acl_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/secondary_dns/acls/{acl_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_acl_delete_acl_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_acl_delete_acl_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsAclDeleteAclArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/acls/{}",
        args.account_id,
        args.acl_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasIdResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/peers
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/peers.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_peer_list_peers_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_peer_list_peers_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsPeerListPeersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/peers",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSchemasResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/secondary_dns/peers
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/secondary_dns/peers.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_peer_create_peer_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_peer_create_peer_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsPeerCreatePeerArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/peers",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/peers/{peer_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/peers/{peer_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_peer_peer_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_peer_peer_details_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsPeerPeerDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/peers/{}",
        args.account_id,
        args.peer_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/secondary_dns/peers/{peer_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/secondary_dns/peers/{peer_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_peer_update_peer_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_peer_update_peer_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsPeerUpdatePeerArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/peers/{}",
        args.account_id,
        args.peer_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSchemasSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/secondary_dns/peers/{peer_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/secondary_dns/peers/{peer_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_peer_delete_peer_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_peer_delete_peer_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsPeerDeletePeerArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsComponentsSchemasIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/peers/{}",
        args.account_id,
        args.peer_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsComponentsSchemasIdResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/tsigs
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/tsigs.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_tsig_list_tsi_gs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_tsig_list_tsi_gs_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsTsigListTsiGsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/tsigs",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/secondary_dns/tsigs
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/secondary_dns/tsigs.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_tsig_create_tsig_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_tsig_create_tsig_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsTsigCreateTsigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/tsigs",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_tsig_tsig_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_tsig_tsig_details_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsTsigTsigDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/tsigs/{}",
        args.account_id,
        args.tsig_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_tsig_update_tsig_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_tsig_update_tsig_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsTsigUpdateTsigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/tsigs/{}",
        args.account_id,
        args.tsig_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/secondary_dns/tsigs/{tsig_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = secondary_dns_tsig_delete_tsig_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn secondary_dns_tsig_delete_tsig_request<F>(
    client: DynNetClient,
    args: &SecondaryDnsTsigDeleteTsigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<SecondaryDnsSchemasIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/secondary_dns/tsigs/{}",
        args.account_id,
        args.tsig_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: SecondaryDnsSchemasIdResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/zerotrust/routes/hostname
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/zerotrust/routes/hostname.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_networks_route_hostname_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_networks_route_hostname_list_request<F>(
    client: DynNetClient,
    args: &ZeroTrustNetworksRouteHostnameListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<TunnelHostnameRouteResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/zerotrust/routes/hostname",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("hostname", args.hostname.as_deref());
    builder = builder.query("tunnel_id", args.tunnel_id.as_deref());
    builder = builder.query("comment", args.comment.as_deref());
    builder = builder.query("existed_at", args.existed_at.as_deref());
    builder = builder.query("is_deleted", args.is_deleted.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("page", args.page.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: TunnelHostnameRouteResponseCollection = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/zerotrust/routes/hostname
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/zerotrust/routes/hostname.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_networks_route_hostname_create_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_networks_route_hostname_create_request<F>(
    client: DynNetClient,
    args: &ZeroTrustNetworksRouteHostnameCreateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<TunnelHostnameRouteResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/zerotrust/routes/hostname",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: TunnelHostnameRouteResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_networks_route_hostname_get_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_networks_route_hostname_get_request<F>(
    client: DynNetClient,
    args: &ZeroTrustNetworksRouteHostnameGetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<TunnelHostnameRouteResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/zerotrust/routes/hostname/{}",
        args.account_id,
        args.hostname_route_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: TunnelHostnameRouteResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_networks_route_hostname_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_networks_route_hostname_update_request<F>(
    client: DynNetClient,
    args: &ZeroTrustNetworksRouteHostnameUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<TunnelHostnameRouteResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/zerotrust/routes/hostname/{}",
        args.account_id,
        args.hostname_route_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: TunnelHostnameRouteResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/zerotrust/routes/hostname/{hostname_route_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_networks_route_hostname_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_networks_route_hostname_delete_request<F>(
    client: DynNetClient,
    args: &ZeroTrustNetworksRouteHostnameDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<TunnelHostnameRouteResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/zerotrust/routes/hostname/{}",
        args.account_id,
        args.hostname_route_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: TunnelHostnameRouteResponseSingle = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /radar/dns/summary/{dimension}
// -----------------------------------------------------------------------------

/// GET /radar/dns/summary/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_dns_summary_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_dns_summary_request<F>(
    client: DynNetClient,
    args: &RadarGetDnsSummaryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsSummaryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/dns/summary/{}",
        args.dimension,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("asn", args.asn.as_deref());
    builder = builder.query("location", args.location.as_deref());
    builder = builder.query("continent", args.continent.as_deref());
    builder = builder.query("cacheHit", args.cache_hit.as_deref());
    builder = builder.query("nodata", args.nodata.as_deref());
    builder = builder.query("protocol", args.protocol.as_deref());
    builder = builder.query("queryType", args.query_type.as_deref());
    builder = builder.query("responseCode", args.response_code.as_deref());
    builder = builder.query("responseTtl", args.response_ttl.as_deref());
    builder = builder.query("dnssec", args.dnssec.as_deref());
    builder = builder.query("dnssecAware", args.dnssec_aware.as_deref());
    builder = builder.query("dnssecE2e", args.dnssec_e2e.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("matchingAnswer", args.matching_answer.as_deref());
    builder = builder.query("tld", args.tld.as_deref());
    builder = builder.query("format", args.format.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: RadarGetDnsSummaryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /radar/dns/timeseries
// -----------------------------------------------------------------------------

/// GET /radar/dns/timeseries.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_dns_timeseries_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_dns_timeseries_request<F>(
    client: DynNetClient,
    args: &RadarGetDnsTimeseriesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsTimeseriesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/dns/timeseries",
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("aggInterval", args.agg_interval.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("asn", args.asn.as_deref());
    builder = builder.query("location", args.location.as_deref());
    builder = builder.query("continent", args.continent.as_deref());
    builder = builder.query("cacheHit", args.cache_hit.as_deref());
    builder = builder.query("nodata", args.nodata.as_deref());
    builder = builder.query("protocol", args.protocol.as_deref());
    builder = builder.query("queryType", args.query_type.as_deref());
    builder = builder.query("responseCode", args.response_code.as_deref());
    builder = builder.query("responseTtl", args.response_ttl.as_deref());
    builder = builder.query("dnssec", args.dnssec.as_deref());
    builder = builder.query("dnssecAware", args.dnssec_aware.as_deref());
    builder = builder.query("dnssecE2e", args.dnssec_e2e.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("matchingAnswer", args.matching_answer.as_deref());
    builder = builder.query("tld", args.tld.as_deref());
    builder = builder.query("format", args.format.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: RadarGetDnsTimeseriesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /radar/dns/timeseries_groups/{dimension}
// -----------------------------------------------------------------------------

/// GET /radar/dns/timeseries_groups/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_dns_timeseries_group_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_dns_timeseries_group_request<F>(
    client: DynNetClient,
    args: &RadarGetDnsTimeseriesGroupArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsTimeseriesGroupResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/dns/timeseries_groups/{}",
        args.dimension,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("aggInterval", args.agg_interval.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("asn", args.asn.as_deref());
    builder = builder.query("location", args.location.as_deref());
    builder = builder.query("continent", args.continent.as_deref());
    builder = builder.query("cacheHit", args.cache_hit.as_deref());
    builder = builder.query("nodata", args.nodata.as_deref());
    builder = builder.query("protocol", args.protocol.as_deref());
    builder = builder.query("queryType", args.query_type.as_deref());
    builder = builder.query("responseCode", args.response_code.as_deref());
    builder = builder.query("responseTtl", args.response_ttl.as_deref());
    builder = builder.query("dnssec", args.dnssec.as_deref());
    builder = builder.query("dnssecAware", args.dnssec_aware.as_deref());
    builder = builder.query("dnssecE2e", args.dnssec_e2e.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("matchingAnswer", args.matching_answer.as_deref());
    builder = builder.query("tld", args.tld.as_deref());
    builder = builder.query("normalization", args.normalization.as_deref());
    builder = builder.query("format", args.format.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: RadarGetDnsTimeseriesGroupResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /radar/dns/top/ases
// -----------------------------------------------------------------------------

/// GET /radar/dns/top/ases.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_dns_top_ases_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_dns_top_ases_request<F>(
    client: DynNetClient,
    args: &RadarGetDnsTopAsesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsTopAsesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/dns/top/ases",
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("limit", args.limit.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("asn", args.asn.as_deref());
    builder = builder.query("location", args.location.as_deref());
    builder = builder.query("continent", args.continent.as_deref());
    builder = builder.query("domain", args.domain.as_deref());
    builder = builder.query("cacheHit", args.cache_hit.as_deref());
    builder = builder.query("nodata", args.nodata.as_deref());
    builder = builder.query("protocol", args.protocol.as_deref());
    builder = builder.query("queryType", args.query_type.as_deref());
    builder = builder.query("responseCode", args.response_code.as_deref());
    builder = builder.query("responseTtl", args.response_ttl.as_deref());
    builder = builder.query("dnssec", args.dnssec.as_deref());
    builder = builder.query("dnssecAware", args.dnssec_aware.as_deref());
    builder = builder.query("dnssecE2e", args.dnssec_e2e.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("matchingAnswer", args.matching_answer.as_deref());
    builder = builder.query("format", args.format.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: RadarGetDnsTopAsesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /radar/dns/top/locations
// -----------------------------------------------------------------------------

/// GET /radar/dns/top/locations.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_dns_top_locations_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_dns_top_locations_request<F>(
    client: DynNetClient,
    args: &RadarGetDnsTopLocationsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsTopLocationsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/dns/top/locations",
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("limit", args.limit.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("asn", args.asn.as_deref());
    builder = builder.query("location", args.location.as_deref());
    builder = builder.query("continent", args.continent.as_deref());
    builder = builder.query("domain", args.domain.as_deref());
    builder = builder.query("cacheHit", args.cache_hit.as_deref());
    builder = builder.query("nodata", args.nodata.as_deref());
    builder = builder.query("protocol", args.protocol.as_deref());
    builder = builder.query("queryType", args.query_type.as_deref());
    builder = builder.query("responseCode", args.response_code.as_deref());
    builder = builder.query("responseTtl", args.response_ttl.as_deref());
    builder = builder.query("dnssec", args.dnssec.as_deref());
    builder = builder.query("dnssecAware", args.dnssec_aware.as_deref());
    builder = builder.query("dnssecE2e", args.dnssec_e2e.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("matchingAnswer", args.matching_answer.as_deref());
    builder = builder.query("tld", args.tld.as_deref());
    builder = builder.query("format", args.format.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: RadarGetDnsTopLocationsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}