foundation_deployment_cloudflare 0.1.1

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

#![cfg(feature = "cloudflare_rules")]
#![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::AaaIdResponse;
use super::shared::DosApiResponseCommon;
use super::shared::MagicVisibilityMnmMnmConfigSingleResponse;
use super::shared::RulesetsRulesetResponse;
use super::shared::RulesetsRulesetsResponse;
use super::shared::AaaApiResponseSingle;
use super::shared::AaaSchemasApiResponseCommon;
use super::shared::AaaUuid;
use super::shared::MagicVisibilityMnmApiResponseCommon;
use super::shared::MagicVisibilityMnmApiResponseSingle;
use super::shared::MagicVisibilityMnmMnmConfig;
use super::shared::MagicVisibilityMnmMnmConfigDefaultSampling;
use super::shared::MagicVisibilityMnmMnmConfigName;
use super::shared::MagicVisibilityMnmMnmConfigRouterIp;
use super::shared::MagicVisibilityMnmMnmConfigWarpDevice;
use super::shared::RulesetsMessage;
use super::shared::RulesetsResponse;
use super::shared::RulesetsResultInfo;
use super::shared::RulesetsRuleset;
use super::shared::RulesetsRulesetKind;
use super::shared::RulesetsRulesetPhase;

use super::shared::ApiResponse;

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

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

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

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

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

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

/// `AaaFilters` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaFilters {
    /// actions property.
    pub actions: Option<Vec<String>>,
    /// affected_asns property.
    pub affected_asns: Option<Vec<String>>,
    /// affected_components property.
    pub affected_components: Option<Vec<String>>,
    /// affected_locations property.
    pub affected_locations: Option<Vec<String>>,
    /// airport_code property.
    pub airport_code: Option<Vec<String>>,
    /// alert_trigger_preferences property.
    pub alert_trigger_preferences: Option<Vec<String>>,
    /// alert_trigger_preferences_value property.
    pub alert_trigger_preferences_value: Option<Vec<String>>,
    /// enabled property.
    pub enabled: Option<Vec<String>>,
    /// environment property.
    pub environment: Option<Vec<String>>,
    /// event property.
    pub event: Option<Vec<String>>,
    /// event_source property.
    pub event_source: Option<Vec<String>>,
    /// event_type property.
    pub event_type: Option<Vec<String>>,
    /// group_by property.
    pub group_by: Option<Vec<String>>,
    /// health_check_id property.
    pub health_check_id: Option<Vec<String>>,
    /// incident_impact property.
    pub incident_impact: Option<Vec<String>>,
    /// input_id property.
    pub input_id: Option<Vec<String>>,
    /// insight_class property.
    pub insight_class: Option<Vec<String>>,
    /// limit property.
    pub limit: Option<Vec<String>>,
    /// logo_tag property.
    pub logo_tag: Option<Vec<String>>,
    /// megabits_per_second property.
    pub megabits_per_second: Option<Vec<String>>,
    /// new_health property.
    pub new_health: Option<Vec<String>>,
    /// new_status property.
    pub new_status: Option<Vec<String>>,
    /// packets_per_second property.
    pub packets_per_second: Option<Vec<String>>,
    /// pool_id property.
    pub pool_id: Option<Vec<String>>,
    /// pop_names property.
    pub pop_names: Option<Vec<String>>,
    /// product property.
    pub product: Option<Vec<String>>,
    /// project_id property.
    pub project_id: Option<Vec<String>>,
    /// protocol property.
    pub protocol: Option<Vec<String>>,
    /// query_tag property.
    pub query_tag: Option<Vec<String>>,
    /// requests_per_second property.
    pub requests_per_second: Option<Vec<String>>,
    /// selectors property.
    pub selectors: Option<Vec<String>>,
    /// services property.
    pub services: Option<Vec<String>>,
    /// slo property.
    pub slo: Option<Vec<String>>,
    /// status property.
    pub status: Option<Vec<String>>,
    /// target_hostname property.
    pub target_hostname: Option<Vec<String>>,
    /// target_ip property.
    pub target_ip: Option<Vec<String>>,
    /// target_zone_name property.
    pub target_zone_name: Option<Vec<String>>,
    /// traffic_exclusions property.
    pub traffic_exclusions: Option<Vec<String>>,
    /// tunnel_id property.
    pub tunnel_id: Option<Vec<String>>,
    /// tunnel_name property.
    pub tunnel_name: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<Vec<String>>,
    /// where property.
    #[serde(rename = "where")]
    pub r#where: Option<Vec<String>>,
    /// zones property.
    pub zones: Option<Vec<String>>,
}

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

/// `AaaPolicies` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaPolicies {
    /// alert_interval property.
    pub alert_interval: Option<AaaAlertInterval>,
    /// alert_type property.
    pub alert_type: Option<AaaAlertType>,
    /// created property.
    pub created: Option<AaaTimestamp>,
    /// description property.
    pub description: Option<AaaSchemasDescription>,
    /// enabled property.
    pub enabled: Option<AaaEnabled>,
    /// filters property.
    pub filters: Option<AaaFilters>,
    /// id property.
    pub id: Option<AaaPolicyId>,
    /// mechanisms property.
    pub mechanisms: Option<AaaMechanisms>,
    /// modified property.
    pub modified: Option<AaaTimestamp>,
    /// name property.
    pub name: Option<AaaSchemasName>,
}

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

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

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

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

/// `AaaSchemasResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaSchemasResultInfo {
    /// 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>,
}

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

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

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

/// `DosDnsProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosDnsProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// created_on property.
    pub created_on: String,
    /// id property.
    pub id: String,
    /// mode property.
    pub mode: String,
    /// modified_on property.
    pub modified_on: String,
    /// name property.
    pub name: String,
    /// profile_sensitivity property.
    pub profile_sensitivity: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

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

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

/// `DosDnsProtectionRuleUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosDnsProtectionRuleUpdate {
    /// burst_sensitivity property.
    pub burst_sensitivity: Option<String>,
    /// mode property.
    pub mode: Option<String>,
    /// profile_sensitivity property.
    pub profile_sensitivity: Option<String>,
    /// rate_sensitivity property.
    pub rate_sensitivity: Option<String>,
}

/// `DosExpressionFilter` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosExpressionFilter {
    /// created_on property.
    pub created_on: String,
    /// expression property.
    pub expression: String,
    /// id property.
    pub id: String,
    /// mode property.
    pub mode: String,
    /// modified_on property.
    pub modified_on: String,
}

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

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

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

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

/// `DosNewDnsProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosNewDnsProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// mode property.
    pub mode: String,
    /// name property.
    pub name: String,
    /// profile_sensitivity property.
    pub profile_sensitivity: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

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

/// `DosNewSynProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosNewSynProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// mitigation_type property.
    pub mitigation_type: Option<String>,
    /// mode property.
    pub mode: String,
    /// name property.
    pub name: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

/// `DosNewTcpFlowProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosNewTcpFlowProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// mode property.
    pub mode: String,
    /// name property.
    pub name: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

/// `DosSynProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosSynProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// created_on property.
    pub created_on: String,
    /// id property.
    pub id: String,
    /// mitigation_type property.
    pub mitigation_type: String,
    /// mode property.
    pub mode: String,
    /// modified_on property.
    pub modified_on: String,
    /// name property.
    pub name: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

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

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

/// `DosSynProtectionRuleUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosSynProtectionRuleUpdate {
    /// burst_sensitivity property.
    pub burst_sensitivity: Option<String>,
    /// mitigation_type property.
    pub mitigation_type: Option<String>,
    /// mode property.
    pub mode: Option<String>,
    /// rate_sensitivity property.
    pub rate_sensitivity: Option<String>,
}

/// `DosTcpFlowProtectionRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosTcpFlowProtectionRule {
    /// burst_sensitivity property.
    pub burst_sensitivity: String,
    /// created_on property.
    pub created_on: String,
    /// id property.
    pub id: String,
    /// mode property.
    pub mode: String,
    /// modified_on property.
    pub modified_on: String,
    /// name property.
    pub name: String,
    /// rate_sensitivity property.
    pub rate_sensitivity: String,
    /// scope property.
    pub scope: String,
}

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

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

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

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

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

/// `ListsBulkOperationCompleted` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsBulkOperationCompleted {
    /// completed property.
    pub completed: ListsCompleted,
    /// id property.
    pub id: ListsOperationId,
    /// status property.
    pub status: String,
}

/// `ListsBulkOperationFailed` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsBulkOperationFailed {
    /// completed property.
    pub completed: ListsCompleted,
    /// error property.
    pub error: String,
    /// id property.
    pub id: ListsOperationId,
    /// status property.
    pub status: String,
}

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

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

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

/// `ListsCreateAListRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsCreateAListRequest {
    /// description property.
    pub description: Option<ListsDescription>,
    /// kind property.
    pub kind: ListsKind,
    /// name property.
    pub name: ListsName,
}

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

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

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

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

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

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

/// `ListsItemBase` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsItemBase {
    /// comment property.
    pub comment: Option<ListsItemComment>,
    /// created_on property.
    pub created_on: ListsCreatedOn,
    /// id property.
    pub id: ListsItemId,
    /// modified_on property.
    pub modified_on: ListsModifiedOn,
}

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

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

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

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

/// `ListsItemRedirect` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsItemRedirect {
    /// include_subdomains property.
    pub include_subdomains: Option<bool>,
    /// preserve_path_suffix property.
    pub preserve_path_suffix: Option<bool>,
    /// preserve_query_string property.
    pub preserve_query_string: Option<bool>,
    /// source_url property.
    pub source_url: String,
    /// status_code property.
    pub status_code: Option<i64>,
    /// subpath_matching property.
    pub subpath_matching: Option<bool>,
    /// target_url property.
    pub target_url: String,
}

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

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

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

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

/// `ListsList` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsList {
    /// created_on property.
    pub created_on: ListsCreatedOn,
    /// description property.
    pub description: Option<ListsDescription>,
    /// id property.
    pub id: ListsListId,
    /// kind property.
    pub kind: ListsKind,
    /// modified_on property.
    pub modified_on: ListsModifiedOn,
    /// name property.
    pub name: ListsName,
    /// num_items property.
    pub num_items: ListsNumItems,
    /// num_referencing_filters property.
    pub num_referencing_filters: ListsNumReferencingFilters,
}

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

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

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

/// `ListsListItemAsnObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemAsnObject {
    /// asn property.
    pub asn: ListsItemAsn,
}

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

/// `ListsListItemHostnameObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemHostnameObject {
    /// hostname property.
    pub hostname: ListsItemHostname,
}

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

/// `ListsListItemIpObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemIpObject {
    /// ip property.
    pub ip: ListsItemIp,
}

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

/// `ListsListItemRedirectObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemRedirectObject {
    /// redirect property.
    pub redirect: ListsItemRedirect,
}

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

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

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

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

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

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

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

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

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

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

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

/// `MagicNetworkMonitoringRulesCreateRulesRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesCreateRulesRequest {
    /// automatic_advertisement property.
    pub automatic_advertisement: Option<MagicVisibilityMnmMnmRuleAutomaticAdvertisement>,
    /// bandwidth property.
    pub bandwidth: Option<MagicVisibilityMnmMnmRuleBandwidthThreshold>,
    /// duration property.
    pub duration: MagicVisibilityMnmMnmRuleDuration,
    /// name property.
    pub name: MagicVisibilityMnmMnmRuleName,
    /// packet_threshold property.
    pub packet_threshold: Option<MagicVisibilityMnmMnmRulePacketThreshold>,
    /// prefixes property.
    pub prefixes: Option<Vec<MagicVisibilityMnmMnmRuleIpPrefix>>,
}

/// `MagicNetworkMonitoringRulesUpdateRuleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRuleRequest {
    /// automatic_advertisement property.
    pub automatic_advertisement: Option<MagicVisibilityMnmMnmRuleAutomaticAdvertisement>,
    /// bandwidth property.
    pub bandwidth: Option<MagicVisibilityMnmMnmRuleBandwidthThreshold>,
    /// duration property.
    pub duration: Option<MagicVisibilityMnmMnmRuleDuration>,
    /// name property.
    pub name: Option<MagicVisibilityMnmMnmRuleName>,
    /// packet_threshold property.
    pub packet_threshold: Option<MagicVisibilityMnmMnmRulePacketThreshold>,
    /// prefixes property.
    pub prefixes: Option<Vec<MagicVisibilityMnmMnmRuleIpPrefix>>,
}

/// `MagicNetworkMonitoringRulesUpdateRulesRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRulesRequest {
    /// automatic_advertisement property.
    pub automatic_advertisement: Option<MagicVisibilityMnmMnmRuleAutomaticAdvertisement>,
    /// bandwidth property.
    pub bandwidth: Option<MagicVisibilityMnmMnmRuleBandwidthThreshold>,
    /// duration property.
    pub duration: MagicVisibilityMnmMnmRuleDuration,
    /// id property.
    pub id: Option<MagicVisibilityMnmRuleIdentifier>,
    /// name property.
    pub name: MagicVisibilityMnmMnmRuleName,
    /// packet_threshold property.
    pub packet_threshold: Option<MagicVisibilityMnmMnmRulePacketThreshold>,
    /// prefixes property.
    pub prefixes: Option<Vec<MagicVisibilityMnmMnmRuleIpPrefix>>,
}

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

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

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

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

/// `MagicVisibilityMnmMnmRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityMnmMnmRule {
    /// automatic_advertisement property.
    pub automatic_advertisement: Option<MagicVisibilityMnmMnmRuleAutomaticAdvertisement>,
    /// bandwidth_threshold property.
    pub bandwidth_threshold: Option<MagicVisibilityMnmMnmRuleBandwidthThreshold>,
    /// duration property.
    pub duration: Option<MagicVisibilityMnmMnmRuleDuration>,
    /// id property.
    pub id: Option<MagicVisibilityMnmRuleIdentifier>,
    /// name property.
    pub name: MagicVisibilityMnmMnmRuleName,
    /// packet_threshold property.
    pub packet_threshold: Option<MagicVisibilityMnmMnmRulePacketThreshold>,
    /// prefix_match property.
    pub prefix_match: Option<MagicVisibilityMnmMnmRulePrefixMatch>,
    /// prefixes property.
    pub prefixes: Vec<MagicVisibilityMnmMnmRuleIpPrefix>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: MagicVisibilityMnmMnmRuleType,
    /// zscore_sensitivity property.
    pub zscore_sensitivity: Option<MagicVisibilityMnmMnmRuleZscoreSensitivity>,
    /// zscore_target property.
    pub zscore_target: Option<MagicVisibilityMnmMnmRuleZscoreTarget>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `MagicVisibilityMnmResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityMnmResultInfo {
    /// 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>,
}

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

/// `NotificationPoliciesCreateANotificationPolicyRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct NotificationPoliciesCreateANotificationPolicyRequest {
    /// alert_interval property.
    pub alert_interval: Option<AaaAlertInterval>,
    /// alert_type property.
    pub alert_type: AaaAlertType,
    /// description property.
    pub description: Option<AaaSchemasDescription>,
    /// enabled property.
    pub enabled: AaaEnabled,
    /// filters property.
    pub filters: Option<AaaFilters>,
    /// mechanisms property.
    pub mechanisms: AaaMechanisms,
    /// name property.
    pub name: AaaSchemasName,
}

/// `NotificationPoliciesUpdateANotificationPolicyRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct NotificationPoliciesUpdateANotificationPolicyRequest {
    /// alert_interval property.
    pub alert_interval: Option<AaaAlertInterval>,
    /// alert_type property.
    pub alert_type: Option<AaaAlertType>,
    /// description property.
    pub description: Option<AaaSchemasDescription>,
    /// enabled property.
    pub enabled: Option<AaaEnabled>,
    /// filters property.
    pub filters: Option<AaaFilters>,
    /// mechanisms property.
    pub mechanisms: Option<AaaMechanisms>,
    /// name property.
    pub name: Option<AaaSchemasName>,
}

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

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

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

/// Arguments for [`notification-policies-list-notification-policies_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct NotificationPoliciesListNotificationPoliciesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`notification-policies-create-a-notification-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct NotificationPoliciesCreateANotificationPolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: NotificationPoliciesCreateANotificationPolicyRequest,
}

/// Arguments for [`notification-policies-get-a-notification-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct NotificationPoliciesGetANotificationPolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
}

/// Arguments for [`notification-policies-update-a-notification-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct NotificationPoliciesUpdateANotificationPolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
    /// Request body.
    pub body: NotificationPoliciesUpdateANotificationPolicyRequest,
}

/// Arguments for [`notification-policies-delete-a-notification-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct NotificationPoliciesDeleteANotificationPolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
}

/// Arguments for [`listDnsProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListDnsProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: 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 [`createDnsProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateDnsProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DosNewDnsProtectionRule,
}

/// Arguments for [`deleteDnsProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteDnsProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getDnsProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetDnsProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`updateDnsProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateDnsProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Request body.
    pub body: DosDnsProtectionRuleUpdate,
}

/// Arguments for [`deleteDnsProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteDnsProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`listSynProtectionFiltersForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListSynProtectionFiltersForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `mode`.
    pub mode: 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 [`createSynProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateSynProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DosNewExpressionFilter,
}

/// Arguments for [`deleteSynProtectionFiltersForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteSynProtectionFiltersForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getSynProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetSynProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
}

/// Arguments for [`updateSynProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateSynProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
    /// Request body.
    pub body: DosExpressionFilterUpdate,
}

/// Arguments for [`deleteSynProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteSynProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
}

/// Arguments for [`listSynProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListSynProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: 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 [`createSynProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateSynProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DosNewSynProtectionRule,
}

/// Arguments for [`deleteSynProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteSynProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getSynProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetSynProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`updateSynProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateSynProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Request body.
    pub body: DosSynProtectionRuleUpdate,
}

/// Arguments for [`deleteSynProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteSynProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`listTcpFlowProtectionFiltersForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListTcpFlowProtectionFiltersForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `mode`.
    pub mode: 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 [`createTcpFlowProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateTcpFlowProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DosNewExpressionFilter,
}

/// Arguments for [`deleteTcpFlowProtectionFiltersForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteTcpFlowProtectionFiltersForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getTcpFlowProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetTcpFlowProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
}

/// Arguments for [`updateTcpFlowProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateTcpFlowProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
    /// Request body.
    pub body: DosExpressionFilterUpdate,
}

/// Arguments for [`deleteTcpFlowProtectionFilter_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteTcpFlowProtectionFilterArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `filter_id`.
    pub filter_id: String,
}

/// Arguments for [`listTcpFlowProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListTcpFlowProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: 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 [`createTcpFlowProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateTcpFlowProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DosNewTcpFlowProtectionRule,
}

/// Arguments for [`deleteTcpFlowProtectionRulesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteTcpFlowProtectionRulesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getTcpFlowProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetTcpFlowProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`updateTcpFlowProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateTcpFlowProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Request body.
    pub body: DosTcpFlowProtectionRuleUpdate,
}

/// Arguments for [`deleteTcpFlowProtectionRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteTcpFlowProtectionRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`magic-network-monitoring-configuration-list-rules-and-account-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationListRulesAndAccountConfigurationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-network-monitoring-rules-list-rules_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesListRulesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-network-monitoring-rules-create-rules_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesCreateRulesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringRulesCreateRulesRequest,
}

/// Arguments for [`magic-network-monitoring-rules-update-rules_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRulesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringRulesUpdateRulesRequest,
}

/// Arguments for [`magic-network-monitoring-rules-get-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesGetRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-network-monitoring-rules-update-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringRulesUpdateRuleRequest,
}

/// Arguments for [`magic-network-monitoring-rules-delete-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesDeleteRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-network-monitoring-rules-update-advertisement-for-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateAdvertisementForRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`lists-get-lists_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsGetListsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`lists-create-a-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsCreateAListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ListsCreateAListRequest,
}

/// Arguments for [`lists-get-bulk-operation-status_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsGetBulkOperationStatusArgs {
    /// Path parameter: `operation_id`.
    pub operation_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`lists-get-a-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsGetAListArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`lists-update-a-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsUpdateAListArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ListsUpdateAListRequest,
}

/// Arguments for [`lists-delete-a-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsDeleteAListArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`lists-get-list-items_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsGetListItemsArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
}

/// Arguments for [`lists-create-list-items_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsCreateListItemsArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: Vec<serde_json::Value>,
}

/// Arguments for [`lists-update-all-list-items_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsUpdateAllListItemsArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: Vec<serde_json::Value>,
}

/// Arguments for [`lists-delete-list-items_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsDeleteListItemsArgs {
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ListsDeleteListItemsRequest,
}

/// Arguments for [`lists-get-a-list-item_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListsGetAListItemArgs {
    /// Path parameter: `item_id`.
    pub item_id: String,
    /// Path parameter: `list_id`.
    pub list_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`listAccountRulesets_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAccountRulesetsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`createAccountRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateAccountRulesetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getAccountEntrypointRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetAccountEntrypointRulesetArgs {
    /// Path parameter: `ruleset_phase`.
    pub ruleset_phase: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`updateAccountEntrypointRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateAccountEntrypointRulesetArgs {
    /// Path parameter: `ruleset_phase`.
    pub ruleset_phase: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`listAccountEntrypointRulesetVersions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAccountEntrypointRulesetVersionsArgs {
    /// Path parameter: `ruleset_phase`.
    pub ruleset_phase: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getAccountEntrypointRulesetVersion_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetAccountEntrypointRulesetVersionArgs {
    /// Path parameter: `ruleset_version`.
    pub ruleset_version: String,
    /// Path parameter: `ruleset_phase`.
    pub ruleset_phase: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getAccountRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetAccountRulesetArgs {
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`updateAccountRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateAccountRulesetArgs {
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`deleteAccountRuleset_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteAccountRulesetArgs {
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`createAccountRulesetRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateAccountRulesetRuleArgs {
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`updateAccountRulesetRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateAccountRulesetRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`deleteAccountRulesetRule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteAccountRulesetRuleArgs {
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`listAccountRulesetVersions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAccountRulesetVersionsArgs {
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`getAccountRulesetVersion_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetAccountRulesetVersionArgs {
    /// Path parameter: `ruleset_version`.
    pub ruleset_version: String,
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`deleteAccountRulesetVersion_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteAccountRulesetVersionArgs {
    /// Path parameter: `ruleset_version`.
    pub ruleset_version: String,
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`listAccountRulesetVersionRulesByTag_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAccountRulesetVersionRulesByTagArgs {
    /// Path parameter: `rule_tag`.
    pub rule_tag: String,
    /// Path parameter: `ruleset_version`.
    pub ruleset_version: String,
    /// Path parameter: `ruleset_id`.
    pub ruleset_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/alerting/v3/policies
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/alerting/v3/policies.
///
/// 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 = notification_policies_list_notification_policies_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn notification_policies_list_notification_policies_request<F>(
    client: DynNetClient,
    args: &NotificationPoliciesListNotificationPoliciesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaPoliciesComponentsSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/alerting/v3/policies",
        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: AaaPoliciesComponentsSchemasResponseCollection = 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}/alerting/v3/policies
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/alerting/v3/policies.
///
/// 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 = notification_policies_create_a_notification_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn notification_policies_create_a_notification_policy_request<F>(
    client: DynNetClient,
    args: &NotificationPoliciesCreateANotificationPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/alerting/v3/policies",
        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: AaaIdResponse = 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}/alerting/v3/policies/{policy_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/alerting/v3/policies/{policy_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 = notification_policies_get_a_notification_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn notification_policies_get_a_notification_policy_request<F>(
    client: DynNetClient,
    args: &NotificationPoliciesGetANotificationPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/alerting/v3/policies/{}",
        args.account_id,
        args.policy_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: AaaSingleResponse = 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}/alerting/v3/policies/{policy_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/alerting/v3/policies/{policy_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 = notification_policies_update_a_notification_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn notification_policies_update_a_notification_policy_request<F>(
    client: DynNetClient,
    args: &NotificationPoliciesUpdateANotificationPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/alerting/v3/policies/{}",
        args.account_id,
        args.policy_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: AaaIdResponse = 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}/alerting/v3/policies/{policy_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/alerting/v3/policies/{policy_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 = notification_policies_delete_a_notification_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn notification_policies_delete_a_notification_policy_request<F>(
    client: DynNetClient,
    args: &NotificationPoliciesDeleteANotificationPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaApiResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/alerting/v3/policies/{}",
        args.account_id,
        args.policy_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: AaaApiResponseCollection = 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}/magic/advanced_dns_protection/configs/dns_protection/rules
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules.
///
/// 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 = list_dns_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_dns_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &ListDnsProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosDnsProtectionRuleListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules",
        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());
    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: DosDnsProtectionRuleListResponse = 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}/magic/advanced_dns_protection/configs/dns_protection/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules.
///
/// 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 = create_dns_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_dns_protection_rule_request<F>(
    client: DynNetClient,
    args: &CreateDnsProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosDnsProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules",
        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: DosDnsProtectionRuleResponse = 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}/magic/advanced_dns_protection/configs/dns_protection/rules
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules.
///
/// 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 = delete_dns_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_dns_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteDnsProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules",
        args.account_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: DosApiResponseCommon = 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}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_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 = get_dns_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_dns_protection_rule_request<F>(
    client: DynNetClient,
    args: &GetDnsProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosDnsProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules/{}",
        args.account_id,
        args.rule_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: DosDnsProtectionRuleResponse = 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}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_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 = update_dns_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_dns_protection_rule_request<F>(
    client: DynNetClient,
    args: &UpdateDnsProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosDnsProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules/{}",
        args.account_id,
        args.rule_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: DosDnsProtectionRuleResponse = 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}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_dns_protection/configs/dns_protection/rules/{rule_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 = delete_dns_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_dns_protection_rule_request<F>(
    client: DynNetClient,
    args: &DeleteDnsProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_dns_protection/configs/dns_protection/rules/{}",
        args.account_id,
        args.rule_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters.
///
/// 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 = list_syn_protection_filters_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_syn_protection_filters_for_account_request<F>(
    client: DynNetClient,
    args: &ListSynProtectionFiltersForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters",
        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("mode", args.mode.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: DosExpressionFilterListResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters.
///
/// 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 = create_syn_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_syn_protection_filter_request<F>(
    client: DynNetClient,
    args: &CreateSynProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters",
        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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters.
///
/// 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 = delete_syn_protection_filters_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_syn_protection_filters_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteSynProtectionFiltersForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters",
        args.account_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_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 = get_syn_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_syn_protection_filter_request<F>(
    client: DynNetClient,
    args: &GetSynProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters/{}",
        args.account_id,
        args.filter_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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_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 = update_syn_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_syn_protection_filter_request<F>(
    client: DynNetClient,
    args: &UpdateSynProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters/{}",
        args.account_id,
        args.filter_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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/filters/{filter_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 = delete_syn_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_syn_protection_filter_request<F>(
    client: DynNetClient,
    args: &DeleteSynProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/filters/{}",
        args.account_id,
        args.filter_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules.
///
/// 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 = list_syn_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_syn_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &ListSynProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosSynProtectionRuleListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules",
        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());
    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: DosSynProtectionRuleListResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules.
///
/// 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 = create_syn_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_syn_protection_rule_request<F>(
    client: DynNetClient,
    args: &CreateSynProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosSynProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules",
        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: DosSynProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules.
///
/// 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 = delete_syn_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_syn_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteSynProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules",
        args.account_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_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 = get_syn_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_syn_protection_rule_request<F>(
    client: DynNetClient,
    args: &GetSynProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosSynProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules/{}",
        args.account_id,
        args.rule_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: DosSynProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_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 = update_syn_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_syn_protection_rule_request<F>(
    client: DynNetClient,
    args: &UpdateSynProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosSynProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules/{}",
        args.account_id,
        args.rule_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: DosSynProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/syn_protection/rules/{rule_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 = delete_syn_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_syn_protection_rule_request<F>(
    client: DynNetClient,
    args: &DeleteSynProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/syn_protection/rules/{}",
        args.account_id,
        args.rule_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters.
///
/// 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 = list_tcp_flow_protection_filters_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_tcp_flow_protection_filters_for_account_request<F>(
    client: DynNetClient,
    args: &ListTcpFlowProtectionFiltersForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters",
        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("mode", args.mode.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: DosExpressionFilterListResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters.
///
/// 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 = create_tcp_flow_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_tcp_flow_protection_filter_request<F>(
    client: DynNetClient,
    args: &CreateTcpFlowProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters",
        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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters.
///
/// 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 = delete_tcp_flow_protection_filters_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_tcp_flow_protection_filters_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteTcpFlowProtectionFiltersForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters",
        args.account_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_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 = get_tcp_flow_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_tcp_flow_protection_filter_request<F>(
    client: DynNetClient,
    args: &GetTcpFlowProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{}",
        args.account_id,
        args.filter_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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_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 = update_tcp_flow_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_tcp_flow_protection_filter_request<F>(
    client: DynNetClient,
    args: &UpdateTcpFlowProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosExpressionFilterResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{}",
        args.account_id,
        args.filter_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: DosExpressionFilterResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{filter_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 = delete_tcp_flow_protection_filter_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_tcp_flow_protection_filter_request<F>(
    client: DynNetClient,
    args: &DeleteTcpFlowProtectionFilterArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/filters/{}",
        args.account_id,
        args.filter_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules.
///
/// 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 = list_tcp_flow_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_tcp_flow_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &ListTcpFlowProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosTcpFlowProtectionRuleListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules",
        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());
    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: DosTcpFlowProtectionRuleListResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules.
///
/// 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 = create_tcp_flow_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_tcp_flow_protection_rule_request<F>(
    client: DynNetClient,
    args: &CreateTcpFlowProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosTcpFlowProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules",
        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: DosTcpFlowProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules.
///
/// 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 = delete_tcp_flow_protection_rules_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_tcp_flow_protection_rules_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteTcpFlowProtectionRulesForAccountArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules",
        args.account_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: DosApiResponseCommon = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_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 = get_tcp_flow_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_tcp_flow_protection_rule_request<F>(
    client: DynNetClient,
    args: &GetTcpFlowProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosTcpFlowProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{}",
        args.account_id,
        args.rule_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: DosTcpFlowProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_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 = update_tcp_flow_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_tcp_flow_protection_rule_request<F>(
    client: DynNetClient,
    args: &UpdateTcpFlowProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosTcpFlowProtectionRuleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{}",
        args.account_id,
        args.rule_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: DosTcpFlowProtectionRuleResponse = 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}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{rule_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 = delete_tcp_flow_protection_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_tcp_flow_protection_rule_request<F>(
    client: DynNetClient,
    args: &DeleteTcpFlowProtectionRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DosApiResponseCommon>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/advanced_tcp_protection/configs/tcp_flow_protection/rules/{}",
        args.account_id,
        args.rule_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: DosApiResponseCommon = 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}/mnm/config/full
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/config/full.
///
/// 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 = magic_network_monitoring_configuration_list_rules_and_account_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_configuration_list_rules_and_account_configuration_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringConfigurationListRulesAndAccountConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmConfigSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/config/full",
        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: MagicVisibilityMnmMnmConfigSingleResponse = 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}/mnm/rules
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/rules.
///
/// 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 = magic_network_monitoring_rules_list_rules_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_list_rules_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesListRulesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesCollectionResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules",
        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: MagicVisibilityMnmMnmRulesCollectionResponse = 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}/mnm/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/mnm/rules.
///
/// 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 = magic_network_monitoring_rules_create_rules_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_create_rules_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesCreateRulesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules",
        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: MagicVisibilityMnmMnmRulesSingleResponse = 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}/mnm/rules
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/mnm/rules.
///
/// 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 = magic_network_monitoring_rules_update_rules_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_update_rules_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesUpdateRulesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules",
        args.account_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: MagicVisibilityMnmMnmRulesSingleResponse = 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}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/rules/{rule_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 = magic_network_monitoring_rules_get_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_get_rule_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesGetRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules/{}",
        args.account_id,
        args.rule_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: MagicVisibilityMnmMnmRulesSingleResponse = 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}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/mnm/rules/{rule_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 = magic_network_monitoring_rules_update_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_update_rule_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesUpdateRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules/{}",
        args.account_id,
        args.rule_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: MagicVisibilityMnmMnmRulesSingleResponse = 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}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/mnm/rules/{rule_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 = magic_network_monitoring_rules_delete_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_delete_rule_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesDeleteRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRulesSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules/{}",
        args.account_id,
        args.rule_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: MagicVisibilityMnmMnmRulesSingleResponse = 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}/mnm/rules/{rule_id}/advertisement
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/mnm/rules/{rule_id}/advertisement.
///
/// 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 = magic_network_monitoring_rules_update_advertisement_for_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_rules_update_advertisement_for_rule_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringRulesUpdateAdvertisementForRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmRuleAdvertisementSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/rules/{}/advertisement",
        args.account_id,
        args.rule_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()))?;

    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: MagicVisibilityMnmMnmRuleAdvertisementSingleResponse = 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}/rules/lists
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists.
///
/// 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 = lists_get_lists_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_get_lists_request<F>(
    client: DynNetClient,
    args: &ListsGetListsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListsResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists",
        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: ListsListsResponseCollection = 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}/rules/lists
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rules/lists.
///
/// 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 = lists_create_a_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_create_a_list_request<F>(
    client: DynNetClient,
    args: &ListsCreateAListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists",
        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: ListsListResponseCollection = 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}/rules/lists/bulk_operations/{operation_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/bulk_operations/{operation_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 = lists_get_bulk_operation_status_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_get_bulk_operation_status_request<F>(
    client: DynNetClient,
    args: &ListsGetBulkOperationStatusArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsBulkOperationResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/bulk_operations/{}",
        args.account_id,
        args.operation_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: ListsBulkOperationResponseSingle = 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}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_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 = lists_get_a_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_get_a_list_request<F>(
    client: DynNetClient,
    args: &ListsGetAListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}",
        args.account_id,
        args.list_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: ListsListResponseCollection = 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}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rules/lists/{list_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 = lists_update_a_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_update_a_list_request<F>(
    client: DynNetClient,
    args: &ListsUpdateAListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}",
        args.account_id,
        args.list_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: ListsListResponseCollection = 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}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rules/lists/{list_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 = lists_delete_a_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_delete_a_list_request<F>(
    client: DynNetClient,
    args: &ListsDeleteAListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListDeleteResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}",
        args.account_id,
        args.list_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: ListsListDeleteResponseCollection = 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}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// 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 = lists_get_list_items_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_get_list_items_request<F>(
    client: DynNetClient,
    args: &ListsGetListItemsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsItemsListResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}/items",
        args.account_id,
        args.list_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("cursor", args.cursor.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("search", args.search.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: ListsItemsListResponseCollection = 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}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// 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 = lists_create_list_items_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_create_list_items_request<F>(
    client: DynNetClient,
    args: &ListsCreateListItemsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListsAsyncResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}/items",
        args.account_id,
        args.list_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: ListsListsAsyncResponse = 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}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// 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 = lists_update_all_list_items_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_update_all_list_items_request<F>(
    client: DynNetClient,
    args: &ListsUpdateAllListItemsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListsAsyncResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}/items",
        args.account_id,
        args.list_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: ListsListsAsyncResponse = 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}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// 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 = lists_delete_list_items_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_delete_list_items_request<F>(
    client: DynNetClient,
    args: &ListsDeleteListItemsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsListsAsyncResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}/items",
        args.account_id,
        args.list_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()))?;

    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: ListsListsAsyncResponse = 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}/rules/lists/{list_id}/items/{item_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_id}/items/{item_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 = lists_get_a_list_item_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn lists_get_a_list_item_request<F>(
    client: DynNetClient,
    args: &ListsGetAListItemArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListsItemResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rules/lists/{}/items/{}",
        args.account_id,
        args.list_id,
        args.item_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: ListsItemResponseSingle = 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}/rulesets
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets.
///
/// 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 = list_account_rulesets_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_account_rulesets_request<F>(
    client: DynNetClient,
    args: &ListAccountRulesetsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets",
        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("cursor", args.cursor.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: RulesetsRulesetsResponse = 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}/rulesets
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rulesets.
///
/// 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 = create_account_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_account_ruleset_request<F>(
    client: DynNetClient,
    args: &CreateAccountRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets",
        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()))?;

    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: RulesetsRulesetResponse = 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}/rulesets/phases/{ruleset_phase}/entrypoint
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint.
///
/// 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 = get_account_entrypoint_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_account_entrypoint_ruleset_request<F>(
    client: DynNetClient,
    args: &GetAccountEntrypointRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/phases/{}/entrypoint",
        args.account_id,
        args.ruleset_phase,
    );
    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: RulesetsRulesetResponse = 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}/rulesets/phases/{ruleset_phase}/entrypoint
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint.
///
/// 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 = update_account_entrypoint_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_account_entrypoint_ruleset_request<F>(
    client: DynNetClient,
    args: &UpdateAccountEntrypointRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/phases/{}/entrypoint",
        args.account_id,
        args.ruleset_phase,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&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: RulesetsRulesetResponse = 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}/rulesets/phases/{ruleset_phase}/entrypoint/versions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint/versions.
///
/// 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 = list_account_entrypoint_ruleset_versions_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_account_entrypoint_ruleset_versions_request<F>(
    client: DynNetClient,
    args: &ListAccountEntrypointRulesetVersionsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/phases/{}/entrypoint/versions",
        args.account_id,
        args.ruleset_phase,
    );
    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: RulesetsRulesetsResponse = 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}/rulesets/phases/{ruleset_phase}/entrypoint/versions/{ruleset_version}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint/versions/{ruleset_version}.
///
/// 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 = get_account_entrypoint_ruleset_version_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_account_entrypoint_ruleset_version_request<F>(
    client: DynNetClient,
    args: &GetAccountEntrypointRulesetVersionArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/phases/{}/entrypoint/versions/{}",
        args.account_id,
        args.ruleset_phase,
        args.ruleset_version,
    );
    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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_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 = get_account_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_account_ruleset_request<F>(
    client: DynNetClient,
    args: &GetAccountRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}",
        args.account_id,
        args.ruleset_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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rulesets/{ruleset_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 = update_account_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_account_ruleset_request<F>(
    client: DynNetClient,
    args: &UpdateAccountRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}",
        args.account_id,
        args.ruleset_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()))?;

    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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_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 = delete_account_ruleset_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_account_ruleset_request<F>(
    client: DynNetClient,
    args: &DeleteAccountRulesetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}",
        args.account_id,
        args.ruleset_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 });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/rulesets/{ruleset_id}/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rulesets/{ruleset_id}/rules.
///
/// 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 = create_account_ruleset_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn create_account_ruleset_rule_request<F>(
    client: DynNetClient,
    args: &CreateAccountRulesetRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/rules",
        args.account_id,
        args.ruleset_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()))?;

    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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_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 = update_account_ruleset_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_account_ruleset_rule_request<F>(
    client: DynNetClient,
    args: &UpdateAccountRulesetRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/rules/{}",
        args.account_id,
        args.ruleset_id,
        args.rule_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()))?;

    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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_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 = delete_account_ruleset_rule_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_account_ruleset_rule_request<F>(
    client: DynNetClient,
    args: &DeleteAccountRulesetRuleArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/rules/{}",
        args.account_id,
        args.ruleset_id,
        args.rule_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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}/versions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions.
///
/// 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 = list_account_ruleset_versions_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_account_ruleset_versions_request<F>(
    client: DynNetClient,
    args: &ListAccountRulesetVersionsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/versions",
        args.account_id,
        args.ruleset_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: RulesetsRulesetsResponse = 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}/rulesets/{ruleset_id}/versions/{ruleset_version}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}.
///
/// 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 = get_account_ruleset_version_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_account_ruleset_version_request<F>(
    client: DynNetClient,
    args: &GetAccountRulesetVersionArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/versions/{}",
        args.account_id,
        args.ruleset_id,
        args.ruleset_version,
    );
    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: RulesetsRulesetResponse = 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}/rulesets/{ruleset_id}/versions/{ruleset_version}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}.
///
/// 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 = delete_account_ruleset_version_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_account_ruleset_version_request<F>(
    client: DynNetClient,
    args: &DeleteAccountRulesetVersionArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/versions/{}",
        args.account_id,
        args.ruleset_id,
        args.ruleset_version,
    );
    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 });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}/by_tag/{rule_tag}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}/by_tag/{rule_tag}.
///
/// 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 = list_account_ruleset_version_rules_by_tag_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_account_ruleset_version_rules_by_tag_request<F>(
    client: DynNetClient,
    args: &ListAccountRulesetVersionRulesByTagArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RulesetsRulesetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/rulesets/{}/versions/{}/by_tag/{}",
        args.account_id,
        args.ruleset_id,
        args.ruleset_version,
        args.rule_tag,
    );
    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: RulesetsRulesetResponse = 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 })
}