foundation_deployment_cloudflare 0.1.3

//! 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_macros::JsonHash;
use foundation_netio::shared::client::http_client::HttpClient;
use foundation_netio::{DynNetClient, PreparedRequestBuilder};
use serde::{Deserialize, Serialize};

// Import shared types used by this module
use super::shared::AaaApiResponseSingle;
use super::shared::AaaIdResponse;
use super::shared::AaaSchemasApiResponseCommon;
use super::shared::AaaUuid;
use super::shared::DosApiResponseCommon;
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::MagicVisibilityMnmMnmConfigSingleResponse;
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::RulesetsRulesetResponse;
use super::shared::RulesetsRulesetsResponse;

use super::shared::ApiResponse;

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

/// `AaaAlertInterval` type.
pub type AaaAlertInterval = String;

/// `AaaAlertType` type.
pub type AaaAlertType = String;

/// `AaaApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaApiResponseCollection {
    /// `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_info` property.
    pub result_info: Option<AaaSchemasResultInfo>,
    /// `success` property.
    pub success: bool,
}

/// `AaaComponentsSchemasMessages` type.
pub type AaaComponentsSchemasMessages = Vec<std::collections::HashMap<String, serde_json::Value>>;

/// `AaaEnabled` type.
pub type AaaEnabled = bool;

/// `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<String>,
    /// `alert_type` property.
    pub alert_type: Option<String>,
    /// `created` property.
    pub created: Option<String>,
    /// `description` property.
    pub description: Option<String>,
    /// `enabled` property.
    pub enabled: Option<bool>,
    /// `filters` property.
    pub filters: Option<AaaFilters>,
    /// `id` property.
    pub id: Option<String>,
    /// `mechanisms` property.
    pub mechanisms: Option<AaaMechanisms>,
    /// `modified` property.
    pub modified: Option<String>,
    /// `name` property.
    pub name: Option<String>,
}

/// `AaaPoliciesComponentsSchemasResponseCollection` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<Vec<AaaPolicies>>>`.
pub type AaaPoliciesComponentsSchemasResponseCollection =
    super::shared::ApiEnvelope<Option<Vec<AaaPolicies>>>;

/// `AaaPolicyId` type.
pub type AaaPolicyId = String;

/// `AaaSchemasDescription` type.
pub type AaaSchemasDescription = String;

/// `AaaSchemasName` type.
pub type AaaSchemasName = String;

/// `AaaSchemasResultInfo` type.
///
/// Same shape as `super::shared::FirewallResultInfoShape`.
pub type AaaSchemasResultInfo = super::shared::FirewallResultInfoShape;

/// `AaaSingleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<AaaPolicies>>`.
pub type AaaSingleResponse = super::shared::ApiEnvelope<Option<AaaPolicies>>;

/// `AaaTimestamp` type.
pub type AaaTimestamp = String;

/// `DosApiResponseCollection` type.
///
/// Same shape as `super::shared::AddressingApiResponseCollectionShape`.
pub type DosApiResponseCollection = super::shared::AddressingApiResponseCollectionShape;

/// `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.
///
/// Same shape as `super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosDnsProtectionRule>>>`.
pub type DosDnsProtectionRuleListResponse =
    super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosDnsProtectionRule>>>;

/// `DosDnsProtectionRuleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<DosDnsProtectionRule>>`.
pub type DosDnsProtectionRuleResponse = super::shared::ApiEnvelope<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.
///
/// Same shape as `super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosExpressionFilter>>>`.
pub type DosExpressionFilterListResponse =
    super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosExpressionFilter>>>;

/// `DosExpressionFilterResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<DosExpressionFilter>>`.
pub type DosExpressionFilterResponse = super::shared::ApiEnvelope<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.
pub type DosMessages = Vec<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.
///
/// Same shape as `super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosSynProtectionRule>>>`.
pub type DosSynProtectionRuleListResponse =
    super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosSynProtectionRule>>>;

/// `DosSynProtectionRuleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<DosSynProtectionRule>>`.
pub type DosSynProtectionRuleResponse = super::shared::ApiEnvelope<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.
///
/// Same shape as `super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<Option<Vec<DosTcpFlowProtectionRule>>>`.
pub type DosTcpFlowProtectionRuleListResponse =
    super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<
        Option<Vec<DosTcpFlowProtectionRule>>,
    >;

/// `DosTcpFlowProtectionRuleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<DosTcpFlowProtectionRule>>`.
pub type DosTcpFlowProtectionRuleResponse =
    super::shared::ApiEnvelope<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.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsApiResponseCollection = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsApiResponseCommon` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsApiResponseCommon = super::shared::ApiEnvelope<serde_json::Value>;

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

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

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

/// `ListsBulkOperationResponseSingle` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsBulkOperationResponseSingle = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsCompleted` type.
pub type ListsCompleted = String;

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

/// `ListsCreatedOn` type.
pub type ListsCreatedOn = String;

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

/// `ListsDeleteListItemsRequestItemsItem` type.
///
/// Same shape as `super::shared::IdObject2`.
pub type ListsDeleteListItemsRequestItemsItem = super::shared::IdObject2;

/// `ListsDescription` type.
pub type ListsDescription = String;

/// `ListsItem` type.
pub type ListsItem = serde_json::Value;

/// `ListsItemAsn` type.
pub type ListsItemAsn = i64;

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

/// `ListsItemComment` type.
pub type ListsItemComment = String;

/// `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.
pub type ListsItemId = String;

/// `ListsItemIp` type.
pub type ListsItemIp = String;

/// `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.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsItemResponseSingle = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsItems` type.
pub type ListsItems = Vec<serde_json::Value>;

/// `ListsItemsListResponseCollection` type.
///
/// Same shape as `super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<serde_json::Value>`.
pub type ListsItemsListResponseCollection =
    super::shared::ApiEnvelopeErrorsMessagesResultInfoSuccess<serde_json::Value>;

/// `ListsKind` type.
pub type ListsKind = serde_json::Value;

/// `ListsList` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsList {
    /// `created_on` property.
    pub created_on: String,
    /// `description` property.
    pub description: Option<String>,
    /// `id` property.
    pub id: String,
    /// `kind` property.
    pub kind: serde_json::Value,
    /// `modified_on` property.
    pub modified_on: String,
    /// `name` property.
    pub name: String,
    /// `num_items` property.
    pub num_items: f64,
    /// `num_referencing_filters` property.
    pub num_referencing_filters: f64,
}

/// `ListsListDeleteResponseCollection` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsListDeleteResponseCollection = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsListId` type.
pub type ListsListId = String;

/// `ListsListItemAsnFull` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemAsnFull {
    /// `asn` property.
    pub asn: i64,
    /// `comment` property.
    pub comment: Option<String>,
    /// `created_on` property.
    pub created_on: String,
    /// `id` property.
    pub id: String,
    /// `modified_on` property.
    pub modified_on: String,
}

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

/// `ListsListItemHostnameFull` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemHostnameFull {
    /// `comment` property.
    pub comment: Option<String>,
    /// `created_on` property.
    pub created_on: String,
    /// `hostname` property.
    pub hostname: ListsItemHostname,
    /// `id` property.
    pub id: String,
    /// `modified_on` property.
    pub modified_on: String,
}

/// `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 {
    /// `comment` property.
    pub comment: Option<String>,
    /// `created_on` property.
    pub created_on: String,
    /// `id` property.
    pub id: String,
    /// `ip` property.
    pub ip: String,
    /// `modified_on` property.
    pub modified_on: String,
}

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

/// `ListsListItemRedirectFull` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListsListItemRedirectFull {
    /// `comment` property.
    pub comment: Option<String>,
    /// `created_on` property.
    pub created_on: String,
    /// `id` property.
    pub id: String,
    /// `modified_on` property.
    pub modified_on: String,
    /// `redirect` property.
    pub redirect: ListsItemRedirect,
}

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

/// `ListsListResponseCollection` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsListResponseCollection = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsListsAsyncResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsListsAsyncResponse = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsListsResponseCollection` type.
///
/// Same shape as `super::shared::ApiEnvelope<serde_json::Value>`.
pub type ListsListsResponseCollection = super::shared::ApiEnvelope<serde_json::Value>;

/// `ListsMessages` type.
pub type ListsMessages = Vec<std::collections::HashMap<String, serde_json::Value>>;

/// `ListsModifiedOn` type.
pub type ListsModifiedOn = String;

/// `ListsName` type.
pub type ListsName = String;

/// `ListsNumItems` type.
pub type ListsNumItems = f64;

/// `ListsNumReferencingFilters` type.
pub type ListsNumReferencingFilters = f64;

/// `ListsOperation` type.
pub type ListsOperation = serde_json::Value;

/// `ListsOperationId` type.
pub type ListsOperationId = String;

/// `ListsUpdateAListRequest` type.
///
/// Same shape as `super::shared::DescriptionObject`.
pub type ListsUpdateAListRequest = super::shared::DescriptionObject;

/// `MagicNetworkMonitoringRulesCreateRulesRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesCreateRulesRequest {
    /// `automatic_advertisement` property.
    pub automatic_advertisement: Option<bool>,
    /// `bandwidth` property.
    pub bandwidth: Option<f64>,
    /// `duration` property.
    pub duration: String,
    /// `name` property.
    pub name: String,
    /// `packet_threshold` property.
    pub packet_threshold: Option<f64>,
    /// `prefixes` property.
    pub prefixes: Option<Vec<String>>,
}

/// `MagicNetworkMonitoringRulesUpdateRuleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRuleRequest {
    /// `automatic_advertisement` property.
    pub automatic_advertisement: Option<bool>,
    /// `bandwidth` property.
    pub bandwidth: Option<f64>,
    /// `duration` property.
    pub duration: Option<String>,
    /// `name` property.
    pub name: Option<String>,
    /// `packet_threshold` property.
    pub packet_threshold: Option<f64>,
    /// `prefixes` property.
    pub prefixes: Option<Vec<String>>,
}

/// `MagicNetworkMonitoringRulesUpdateRulesRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringRulesUpdateRulesRequest {
    /// `automatic_advertisement` property.
    pub automatic_advertisement: Option<bool>,
    /// `bandwidth` property.
    pub bandwidth: Option<f64>,
    /// `duration` property.
    pub duration: String,
    /// `id` property.
    pub id: Option<String>,
    /// `name` property.
    pub name: String,
    /// `packet_threshold` property.
    pub packet_threshold: Option<f64>,
    /// `prefixes` property.
    pub prefixes: Option<Vec<String>>,
}

/// `MagicVisibilityMnmApiResponseCollection` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityMnmApiResponseCollection {
    /// `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: Option<Vec<serde_json::Value>>,
    /// `result_info` property.
    pub result_info: Option<MagicVisibilityMnmResultInfo>,
    /// `success` property.
    pub success: bool,
}

/// `MagicVisibilityMnmMessages` type.
pub type MagicVisibilityMnmMessages = Vec<std::collections::HashMap<String, serde_json::Value>>;

/// `MagicVisibilityMnmMnmConfigRouterIps` type.
pub type MagicVisibilityMnmMnmConfigRouterIps = Vec<String>;

/// `MagicVisibilityMnmMnmConfigWarpDevices` type.
pub type MagicVisibilityMnmMnmConfigWarpDevices = Vec<MagicVisibilityMnmMnmConfigWarpDevice>;

/// `MagicVisibilityMnmMnmRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityMnmMnmRule {
    /// `automatic_advertisement` property.
    pub automatic_advertisement: Option<bool>,
    /// `bandwidth_threshold` property.
    pub bandwidth_threshold: Option<f64>,
    /// `duration` property.
    pub duration: Option<String>,
    /// `id` property.
    pub id: Option<String>,
    /// `name` property.
    pub name: String,
    /// `packet_threshold` property.
    pub packet_threshold: Option<f64>,
    /// `prefix_match` property.
    pub prefix_match: Option<String>,
    /// `prefixes` property.
    pub prefixes: Vec<String>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: String,
    /// `zscore_sensitivity` property.
    pub zscore_sensitivity: Option<String>,
    /// `zscore_target` property.
    pub zscore_target: Option<String>,
}

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

/// `MagicVisibilityMnmMnmRuleAdvertisementSingleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<MagicVisibilityMnmMnmRuleAdvertisableResponse>>`.
pub type MagicVisibilityMnmMnmRuleAdvertisementSingleResponse =
    super::shared::ApiEnvelope<Option<MagicVisibilityMnmMnmRuleAdvertisableResponse>>;

/// `MagicVisibilityMnmMnmRuleAutomaticAdvertisement` type.
pub type MagicVisibilityMnmMnmRuleAutomaticAdvertisement = bool;

/// `MagicVisibilityMnmMnmRuleBandwidthThreshold` type.
pub type MagicVisibilityMnmMnmRuleBandwidthThreshold = f64;

/// `MagicVisibilityMnmMnmRuleDuration` type.
pub type MagicVisibilityMnmMnmRuleDuration = String;

/// `MagicVisibilityMnmMnmRuleIpPrefix` type.
pub type MagicVisibilityMnmMnmRuleIpPrefix = String;

/// `MagicVisibilityMnmMnmRuleIpPrefixes` type.
pub type MagicVisibilityMnmMnmRuleIpPrefixes = Vec<String>;

/// `MagicVisibilityMnmMnmRuleName` type.
pub type MagicVisibilityMnmMnmRuleName = String;

/// `MagicVisibilityMnmMnmRulePacketThreshold` type.
pub type MagicVisibilityMnmMnmRulePacketThreshold = f64;

/// `MagicVisibilityMnmMnmRulePrefixMatch` type.
pub type MagicVisibilityMnmMnmRulePrefixMatch = String;

/// `MagicVisibilityMnmMnmRuleType` type.
pub type MagicVisibilityMnmMnmRuleType = String;

/// `MagicVisibilityMnmMnmRuleZscoreSensitivity` type.
pub type MagicVisibilityMnmMnmRuleZscoreSensitivity = String;

/// `MagicVisibilityMnmMnmRuleZscoreTarget` type.
pub type MagicVisibilityMnmMnmRuleZscoreTarget = String;

/// `MagicVisibilityMnmMnmRulesCollectionResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityMnmMnmRulesCollectionResponse {
    /// `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: Option<Vec<MagicVisibilityMnmMnmRule>>,
    /// `result_info` property.
    pub result_info: Option<MagicVisibilityMnmResultInfo>,
    /// `success` property.
    pub success: bool,
}

/// `MagicVisibilityMnmMnmRulesSingleResponse` type.
///
/// Same shape as `super::shared::ApiEnvelope<Option<MagicVisibilityMnmMnmRule>>`.
pub type MagicVisibilityMnmMnmRulesSingleResponse =
    super::shared::ApiEnvelope<Option<MagicVisibilityMnmMnmRule>>;

/// `MagicVisibilityMnmResultInfo` type.
///
/// Same shape as `super::shared::FirewallResultInfoShape`.
pub type MagicVisibilityMnmResultInfo = super::shared::FirewallResultInfoShape;

/// `MagicVisibilityMnmRuleIdentifier` type.
pub type MagicVisibilityMnmRuleIdentifier = String;

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

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

/// `RulesetsErrors` type.
pub type RulesetsErrors = Vec<RulesetsMessage>;

/// `RulesetsMessages` type.
pub type RulesetsMessages = Vec<RulesetsMessage>;

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

/// Arguments for [`notification-policies-list-notification-policies_request`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type NotificationPoliciesListNotificationPoliciesArgs = super::shared::AccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdPolicyIdArgs`.
pub type NotificationPoliciesGetANotificationPolicyArgs = super::shared::AccountIdPolicyIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdPolicyIdArgs`.
pub type NotificationPoliciesDeleteANotificationPolicyArgs = super::shared::AccountIdPolicyIdArgs;

/// Arguments for [`listDnsProtectionRulesForAccount_request`].
///
/// Same shape as `super::shared::SubscriptionsListArgsShape`.
pub type ListDnsProtectionRulesForAccountArgs = super::shared::SubscriptionsListArgsShape;

/// 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`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type DeleteDnsProtectionRulesForAccountArgs = super::shared::AccountIdArgs;

/// Arguments for [`getDnsProtectionRule_request`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type GetDnsProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type DeleteDnsProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// Arguments for [`listSynProtectionFiltersForAccount_request`].
///
/// Same shape as `super::shared::ListSynProtectionFiltersForAccountArgsShape`.
pub type ListSynProtectionFiltersForAccountArgs =
    super::shared::ListSynProtectionFiltersForAccountArgsShape;

/// 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`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type DeleteSynProtectionFiltersForAccountArgs = super::shared::AccountIdArgs;

/// Arguments for [`getSynProtectionFilter_request`].
///
/// Same shape as `super::shared::AccountIdFilterIdArgs`.
pub type GetSynProtectionFilterArgs = super::shared::AccountIdFilterIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdFilterIdArgs`.
pub type DeleteSynProtectionFilterArgs = super::shared::AccountIdFilterIdArgs;

/// Arguments for [`listSynProtectionRulesForAccount_request`].
///
/// Same shape as `super::shared::SubscriptionsListArgsShape`.
pub type ListSynProtectionRulesForAccountArgs = super::shared::SubscriptionsListArgsShape;

/// 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`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type DeleteSynProtectionRulesForAccountArgs = super::shared::AccountIdArgs;

/// Arguments for [`getSynProtectionRule_request`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type GetSynProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type DeleteSynProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// Arguments for [`listTcpFlowProtectionFiltersForAccount_request`].
///
/// Same shape as `super::shared::ListSynProtectionFiltersForAccountArgsShape`.
pub type ListTcpFlowProtectionFiltersForAccountArgs =
    super::shared::ListSynProtectionFiltersForAccountArgsShape;

/// Arguments for [`createTcpFlowProtectionFilter_request`].
///
/// Same shape as `CreateSynProtectionFilterArgs`.
pub type CreateTcpFlowProtectionFilterArgs = CreateSynProtectionFilterArgs;

/// Arguments for [`deleteTcpFlowProtectionFiltersForAccount_request`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type DeleteTcpFlowProtectionFiltersForAccountArgs = super::shared::AccountIdArgs;

/// Arguments for [`getTcpFlowProtectionFilter_request`].
///
/// Same shape as `super::shared::AccountIdFilterIdArgs`.
pub type GetTcpFlowProtectionFilterArgs = super::shared::AccountIdFilterIdArgs;

/// Arguments for [`updateTcpFlowProtectionFilter_request`].
///
/// Same shape as `UpdateSynProtectionFilterArgs`.
pub type UpdateTcpFlowProtectionFilterArgs = UpdateSynProtectionFilterArgs;

/// Arguments for [`deleteTcpFlowProtectionFilter_request`].
///
/// Same shape as `super::shared::AccountIdFilterIdArgs`.
pub type DeleteTcpFlowProtectionFilterArgs = super::shared::AccountIdFilterIdArgs;

/// Arguments for [`listTcpFlowProtectionRulesForAccount_request`].
///
/// Same shape as `super::shared::SubscriptionsListArgsShape`.
pub type ListTcpFlowProtectionRulesForAccountArgs = super::shared::SubscriptionsListArgsShape;

/// 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`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type DeleteTcpFlowProtectionRulesForAccountArgs = super::shared::AccountIdArgs;

/// Arguments for [`getTcpFlowProtectionRule_request`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type GetTcpFlowProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdRuleIdArgs`.
pub type DeleteTcpFlowProtectionRuleArgs = super::shared::AccountIdRuleIdArgs;

/// Arguments for [`magic-network-monitoring-configuration-list-rules-and-account-configuration_request`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type MagicNetworkMonitoringConfigurationListRulesAndAccountConfigurationArgs =
    super::shared::AccountIdArgs;

/// Arguments for [`magic-network-monitoring-rules-list-rules_request`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type MagicNetworkMonitoringRulesListRulesArgs = super::shared::AccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::RuleIdAccountIdArgs`.
pub type MagicNetworkMonitoringRulesGetRuleArgs = super::shared::RuleIdAccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::RuleIdAccountIdArgs`.
pub type MagicNetworkMonitoringRulesDeleteRuleArgs = super::shared::RuleIdAccountIdArgs;

/// Arguments for [`magic-network-monitoring-rules-update-advertisement-for-rule_request`].
///
/// Same shape as `super::shared::RuleIdAccountIdArgs`.
pub type MagicNetworkMonitoringRulesUpdateAdvertisementForRuleArgs =
    super::shared::RuleIdAccountIdArgs;

/// Arguments for [`lists-get-lists_request`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type ListsGetListsArgs = super::shared::AccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::ListIdAccountIdArgs`.
pub type ListsGetAListArgs = super::shared::ListIdAccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::ListIdAccountIdArgs`.
pub type ListsDeleteAListArgs = super::shared::ListIdAccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::ListIdAccountIdBodyArgs`.
pub type ListsCreateListItemsArgs = super::shared::ListIdAccountIdBodyArgs;

/// Arguments for [`lists-update-all-list-items_request`].
///
/// Same shape as `super::shared::ListIdAccountIdBodyArgs`.
pub type ListsUpdateAllListItemsArgs = super::shared::ListIdAccountIdBodyArgs;

/// 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`].
///
/// Same shape as `super::shared::AccountIdArgs`.
pub type CreateAccountRulesetArgs = super::shared::AccountIdArgs;

/// Arguments for [`getAccountEntrypointRuleset_request`].
///
/// Same shape as `super::shared::RulesetPhaseAccountIdArgs`.
pub type GetAccountEntrypointRulesetArgs = super::shared::RulesetPhaseAccountIdArgs;

/// Arguments for [`updateAccountEntrypointRuleset_request`].
///
/// Same shape as `super::shared::RulesetPhaseAccountIdArgs`.
pub type UpdateAccountEntrypointRulesetArgs = super::shared::RulesetPhaseAccountIdArgs;

/// Arguments for [`listAccountEntrypointRulesetVersions_request`].
///
/// Same shape as `super::shared::RulesetPhaseAccountIdArgs`.
pub type ListAccountEntrypointRulesetVersionsArgs = super::shared::RulesetPhaseAccountIdArgs;

/// 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`].
///
/// Same shape as `super::shared::RulesetIdAccountIdArgs`.
pub type GetAccountRulesetArgs = super::shared::RulesetIdAccountIdArgs;

/// Arguments for [`updateAccountRuleset_request`].
///
/// Same shape as `super::shared::RulesetIdAccountIdArgs`.
pub type UpdateAccountRulesetArgs = super::shared::RulesetIdAccountIdArgs;

/// Arguments for [`deleteAccountRuleset_request`].
///
/// Same shape as `super::shared::RulesetIdAccountIdArgs`.
pub type DeleteAccountRulesetArgs = super::shared::RulesetIdAccountIdArgs;

/// Arguments for [`createAccountRulesetRule_request`].
///
/// Same shape as `super::shared::RulesetIdAccountIdArgs`.
pub type CreateAccountRulesetRuleArgs = super::shared::RulesetIdAccountIdArgs;

/// Arguments for [`updateAccountRulesetRule_request`].
///
/// Same shape as `super::shared::RuleIdRulesetIdAccountIdArgs`.
pub type UpdateAccountRulesetRuleArgs = super::shared::RuleIdRulesetIdAccountIdArgs;

/// Arguments for [`deleteAccountRulesetRule_request`].
///
/// Same shape as `super::shared::RuleIdRulesetIdAccountIdArgs`.
pub type DeleteAccountRulesetRuleArgs = super::shared::RuleIdRulesetIdAccountIdArgs;

/// Arguments for [`listAccountRulesetVersions_request`].
///
/// Same shape as `super::shared::RulesetIdAccountIdArgs`.
pub type ListAccountRulesetVersionsArgs = super::shared::RulesetIdAccountIdArgs;

/// Arguments for [`getAccountRulesetVersion_request`].
///
/// Same shape as `super::shared::RulesetVersionRulesetIdAccountIdArgs`.
pub type GetAccountRulesetVersionArgs = super::shared::RulesetVersionRulesetIdAccountIdArgs;

/// Arguments for [`deleteAccountRulesetVersion_request`].
///
/// Same shape as `super::shared::RulesetVersionRulesetIdAccountIdArgs`.
pub type DeleteAccountRulesetVersionArgs = super::shared::RulesetVersionRulesetIdAccountIdArgs;

/// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

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

/// POST /accounts/{account_id}/alerting/v3/policies.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

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

/// GET /accounts/{account_id}/alerting/v3/policies/{policy_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/alerting/v3/policies/{policy_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/alerting/v3/policies/{policy_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/alerting/v3/policies/{policy_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/alerting/v3/policies/{policy_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/mnm/config/full
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/config/full.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/mnm/rules
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/rules.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/mnm/rules
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/mnm/rules.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/mnm/rules
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/mnm/rules.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/mnm/rules/{rule_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/mnm/rules/{rule_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/mnm/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/mnm/rules/{rule_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/mnm/rules/{rule_id}/advertisement
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/mnm/rules/{rule_id}/advertisement.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rules/lists
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/rules/lists
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rules/lists.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rules/lists/bulk_operations/{operation_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/bulk_operations/{operation_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rules/lists/{list_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/rules/lists/{list_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rules/lists/{list_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/rules/lists/{list_id}/items
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rules/lists/{list_id}/items.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rules/lists/{list_id}/items/{item_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rules/lists/{list_id}/items/{item_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

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

/// POST /accounts/{account_id}/rulesets.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint/versions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/phases/{ruleset_phase}/entrypoint/versions.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/rulesets/{ruleset_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/rulesets/{ruleset_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_without_body(client.into(), builder.build()).await
}

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

/// POST /accounts/{account_id}/rulesets/{ruleset_id}/rules.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/rules/{rule_id}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

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

/// GET /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/rulesets/{ruleset_id}/versions/{ruleset_version}.
///
/// Takes a client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_without_body(client.into(), builder.build()).await
}

// -----------------------------------------------------------------------------
// 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 client and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request: a `DynNetClient`, or an `ApiClient` carrying the `BodyLimits` the response is read under
/// * `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: impl Into<super::shared::ApiClient>,
    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);
    }

    super::shared::send_json(client.into(), builder.build()).await
}