foundation_deployment_cloudflare 0.1.1

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

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

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

// Import shared types used by this module
use super::shared::AddressingApiResponseCollection;
use super::shared::DosApiResponseCommon;
use super::shared::AddressingApiResponseCommon;

use super::shared::ApiResponse;

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

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

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

/// `AddressingAddressMaps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AddressingAddressMaps {
    /// can_delete property.
    pub can_delete: Option<AddressingCanDelete>,
    /// can_modify_ips property.
    pub can_modify_ips: Option<AddressingCanModifyIps>,
    /// created_at property.
    pub created_at: Option<AddressingTimestamp>,
    /// default_sni property.
    pub default_sni: Option<AddressingDefaultSni>,
    /// description property.
    pub description: Option<AddressingSchemasDescription>,
    /// enabled property.
    pub enabled: Option<AddressingEnabled>,
    /// id property.
    pub id: Option<AddressingAddressMapIdentifier>,
    /// modified_at property.
    pub modified_at: Option<AddressingTimestamp>,
}

/// `AddressingAddressMapsMembershipRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AddressingAddressMapsMembershipRequest {
    /// identifier property.
    pub identifier: Option<AddressingIdentifier>,
    /// kind property.
    pub kind: Option<AddressingKind>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AddressingIpamDelegations` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AddressingIpamDelegations {
    /// cidr property.
    pub cidr: Option<AddressingCidr>,
    /// created_at property.
    pub created_at: Option<AddressingTimestamp>,
    /// delegated_account_id property.
    pub delegated_account_id: Option<AddressingDelegatedAccountIdentifier>,
    /// id property.
    pub id: Option<AddressingDelegationIdentifier>,
    /// modified_at property.
    pub modified_at: Option<AddressingTimestamp>,
    /// parent_prefix_id property.
    pub parent_prefix_id: Option<AddressingPrefixIdentifier>,
}

/// `AddressingIpamPrefixes` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AddressingIpamPrefixes {
    /// account_id property.
    pub account_id: Option<AddressingAccountIdentifier>,
    /// advertised property.
    pub advertised: Option<AddressingAdvertised>,
    /// advertised_modified_at property.
    pub advertised_modified_at: Option<AddressingAdvertisedModifiedAtNullable>,
    /// approved property.
    pub approved: Option<AddressingApproved>,
    /// asn property.
    pub asn: Option<AddressingAsn>,
    /// cidr property.
    pub cidr: Option<AddressingCidr>,
    /// created_at property.
    pub created_at: Option<AddressingTimestamp>,
    /// delegate_loa_creation property.
    pub delegate_loa_creation: Option<AddressingDelegateLoaCreation>,
    /// description property.
    pub description: Option<AddressingDescription>,
    /// id property.
    pub id: Option<AddressingPrefixIdentifier>,
    /// irr_validation_state property.
    pub irr_validation_state: Option<AddressingValidationState>,
    /// loa_document_id property.
    pub loa_document_id: Option<AddressingLoaDocumentIdentifier>,
    /// modified_at property.
    pub modified_at: Option<AddressingTimestamp>,
    /// on_demand_enabled property.
    pub on_demand_enabled: Option<AddressingOnDemandEnabled>,
    /// on_demand_locked property.
    pub on_demand_locked: Option<AddressingOnDemandLocked>,
    /// ownership_validation_state property.
    pub ownership_validation_state: Option<AddressingValidationState>,
    /// ownership_validation_token property.
    pub ownership_validation_token: Option<AddressingOwnershipValidationToken>,
    /// rpki_validation_state property.
    pub rpki_validation_state: Option<AddressingValidationState>,
}

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

/// `AddressingLease` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AddressingLease {
    /// active_from property.
    pub active_from: Option<String>,
    /// cidrs property.
    pub cidrs: Option<Vec<AddressingSchemasCidr>>,
    /// created_at property.
    pub created_at: Option<AddressingCreatedAt>,
    /// id property.
    pub id: Option<AddressingLeaseId>,
    /// modified_at property.
    pub modified_at: Option<AddressingModifiedAt>,
    /// owner_id property.
    pub owner_id: Option<AddressingLeaseOwnerId>,
    /// purpose property.
    pub purpose: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `DosInfraPrefix` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosInfraPrefix {
    /// comment property.
    pub comment: String,
    /// created_on property.
    pub created_on: String,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// modified_on property.
    pub modified_on: String,
    /// prefix property.
    pub prefix: String,
}

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

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

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

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

/// `DosNewInfraPrefix` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosNewInfraPrefix {
    /// comment property.
    pub comment: String,
    /// enabled property.
    pub enabled: bool,
    /// prefix property.
    pub prefix: String,
}

/// `DosNewPrefix` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosNewPrefix {
    /// comment property.
    pub comment: String,
    /// excluded property.
    pub excluded: bool,
    /// prefix property.
    pub prefix: String,
}

/// `DosPrefix` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DosPrefix {
    /// comment property.
    pub comment: String,
    /// created_on property.
    pub created_on: String,
    /// excluded property.
    pub excluded: bool,
    /// id property.
    pub id: String,
    /// modified_on property.
    pub modified_on: String,
    /// prefix property.
    pub prefix: String,
}

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

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

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

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

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

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

/// `IpAddressManagementAddressMapsCreateAddressMapRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IpAddressManagementAddressMapsCreateAddressMapRequest {
    /// description property.
    pub description: Option<AddressingSchemasDescription>,
    /// enabled property.
    pub enabled: Option<AddressingEnabled>,
    /// ips property.
    pub ips: Option<Vec<AddressingIpAddress>>,
    /// memberships property.
    pub memberships: Option<Vec<AddressingAddressMapsMembershipRequest>>,
}

/// `IpAddressManagementAddressMapsUpdateAddressMapRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IpAddressManagementAddressMapsUpdateAddressMapRequest {
    /// default_sni property.
    pub default_sni: Option<AddressingDefaultSni>,
    /// description property.
    pub description: Option<AddressingSchemasDescription>,
    /// enabled property.
    pub enabled: Option<AddressingEnabled>,
}

/// `IpAddressManagementPrefixDelegationCreatePrefixDelegationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IpAddressManagementPrefixDelegationCreatePrefixDelegationRequest {
    /// cidr property.
    pub cidr: AddressingCidr,
    /// delegated_account_id property.
    pub delegated_account_id: AddressingDelegatedAccountIdentifier,
}

/// `IpAddressManagementPrefixesAddPrefixRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IpAddressManagementPrefixesAddPrefixRequest {
    /// asn property.
    pub asn: AddressingAsn,
    /// cidr property.
    pub cidr: AddressingCidr,
    /// delegate_loa_creation property.
    pub delegate_loa_creation: Option<AddressingDelegateLoaCreation>,
    /// description property.
    pub description: Option<AddressingDescription>,
    /// loa_document_id property.
    pub loa_document_id: Option<AddressingLoaDocumentIdentifier>,
}

/// `IpAddressManagementPrefixesUpdatePrefixDescriptionRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IpAddressManagementPrefixesUpdatePrefixDescriptionRequest {
    /// description property.
    pub description: AddressingDescription,
}

/// `MagicAccountApp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAccountApp {
    /// account_app_id property.
    pub account_app_id: MagicAccountAppId,
    /// hostnames property.
    pub hostnames: Option<Vec<String>>,
    /// ip_subnets property.
    pub ip_subnets: Option<Vec<serde_json::Value>>,
    /// name property.
    pub name: Option<MagicAppName>,
    /// source_subnets property.
    pub source_subnets: Option<Vec<serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<MagicAppType>,
}

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

/// `MagicAcl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAcl {
    /// description property.
    pub description: Option<String>,
    /// forward_locally property.
    pub forward_locally: Option<MagicForwardLocally>,
    /// id property.
    pub id: Option<MagicIdentifier>,
    /// lan_1 property.
    pub lan_1: Option<MagicLanAclConfiguration>,
    /// lan_2 property.
    pub lan_2: Option<MagicLanAclConfiguration>,
    /// name property.
    pub name: Option<String>,
    /// protocols property.
    pub protocols: Option<Vec<String>>,
    /// unidirectional property.
    pub unidirectional: Option<MagicUnidirectional>,
}

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

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

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

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

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

/// `MagicAclUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAclUpdateRequest {
    /// description property.
    pub description: Option<String>,
    /// forward_locally property.
    pub forward_locally: Option<MagicForwardLocally>,
    /// lan_1 property.
    pub lan_1: Option<MagicLanAclConfiguration>,
    /// lan_2 property.
    pub lan_2: Option<MagicLanAclConfiguration>,
    /// name property.
    pub name: Option<String>,
    /// protocols property.
    pub protocols: Option<Vec<String>>,
    /// unidirectional property.
    pub unidirectional: Option<MagicUnidirectional>,
}

/// `MagicAclsAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAclsAddSingleRequest {
    /// description property.
    pub description: Option<String>,
    /// forward_locally property.
    pub forward_locally: Option<MagicForwardLocally>,
    /// lan_1 property.
    pub lan_1: MagicLanAclConfiguration,
    /// lan_2 property.
    pub lan_2: MagicLanAclConfiguration,
    /// name property.
    pub name: String,
    /// protocols property.
    pub protocols: Option<Vec<String>>,
    /// unidirectional property.
    pub unidirectional: Option<MagicUnidirectional>,
}

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

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

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

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

/// `MagicAppAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAppAddSingleRequest {
    /// hostnames property.
    pub hostnames: Option<Vec<String>>,
    /// ip_subnets property.
    pub ip_subnets: Option<Vec<serde_json::Value>>,
    /// name property.
    pub name: MagicAppName,
    /// source_subnets property.
    pub source_subnets: Option<Vec<serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: MagicAppType,
}

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

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

/// `MagicAppConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAppConfig {
    /// `breakout` property.
    pub breakout: Option<MagicAppBreakout>,
    /// `id` property.
    pub id: MagicIdentifier,
    /// `preferred_wans` property.
    pub preferred_wans: Option<Vec<MagicIdentifier>>,
    /// `priority` property.
    pub priority: Option<MagicAppPriority>,
    /// `site_id` property.
    pub site_id: MagicIdentifier,
}

/// `MagicAppConfigAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAppConfigAddSingleRequest {
    /// `breakout` property.
    pub breakout: Option<MagicAppBreakout>,
    /// `preferred_wans` property.
    pub preferred_wans: Option<Vec<MagicIdentifier>>,
    /// `priority` property.
    pub priority: Option<MagicAppPriority>,
}

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

/// `MagicAppConfigUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAppConfigUpdateRequest {
    /// account_app_id property.
    pub account_app_id: Option<MagicAccountAppId>,
    /// breakout property.
    pub breakout: Option<MagicAppBreakout>,
    /// managed_app_id property.
    pub managed_app_id: Option<MagicManagedAppId>,
    /// preferred_wans property.
    pub preferred_wans: Option<Vec<MagicIdentifier>>,
    /// priority property.
    pub priority: Option<MagicAppPriority>,
}

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

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

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

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

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

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

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

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

/// `MagicAppUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicAppUpdateRequest {
    /// hostnames property.
    pub hostnames: Option<Vec<String>>,
    /// ip_subnets property.
    pub ip_subnets: Option<Vec<serde_json::Value>>,
    /// name property.
    pub name: Option<MagicAppName>,
    /// source_subnets property.
    pub source_subnets: Option<Vec<serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<MagicAppType>,
}

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

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

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

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

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

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

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

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

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

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

/// `MagicCreateRouteRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicCreateRouteRequest {
    /// description property.
    pub description: Option<MagicDescription>,
    /// nexthop property.
    pub nexthop: MagicNexthop,
    /// prefix property.
    pub prefix: MagicPrefix,
    /// priority property.
    pub priority: MagicPriority,
    /// scope property.
    pub scope: Option<MagicScope>,
    /// weight property.
    pub weight: Option<MagicWeight>,
}

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

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

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

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

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

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

/// `MagicLan` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLan {
    /// bond_id property.
    pub bond_id: Option<MagicBondId>,
    /// ha_link property.
    pub ha_link: Option<bool>,
    /// id property.
    pub id: Option<MagicIdentifier>,
    /// is_breakout property.
    pub is_breakout: Option<bool>,
    /// is_prioritized property.
    pub is_prioritized: Option<bool>,
    /// name property.
    pub name: Option<String>,
    /// nat property.
    pub nat: Option<MagicNat>,
    /// physport property.
    pub physport: Option<MagicPort>,
    /// routed_subnets property.
    pub routed_subnets: Option<Vec<MagicRoutedSubnet>>,
    /// site_id property.
    pub site_id: Option<MagicIdentifier>,
    /// static_addressing property.
    pub static_addressing: Option<MagicLanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

/// `MagicLanAclConfiguration` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLanAclConfiguration {
    /// lan_id property.
    pub lan_id: String,
    /// lan_name property.
    pub lan_name: Option<String>,
    /// port_ranges property.
    pub port_ranges: Option<Vec<MagicAclPortRange>>,
    /// ports property.
    pub ports: Option<Vec<MagicPort>>,
    /// subnets property.
    pub subnets: Option<Vec<MagicAclSubnet>>,
}

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

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

/// `MagicLanDhcpServer` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLanDhcpServer {
    /// dhcp_pool_end property.
    pub dhcp_pool_end: Option<MagicIpAddress>,
    /// dhcp_pool_start property.
    pub dhcp_pool_start: Option<MagicIpAddress>,
    /// dns_server property.
    pub dns_server: Option<MagicIpAddress>,
    /// dns_servers property.
    pub dns_servers: Option<Vec<MagicIpAddress>>,
    /// reservations property.
    pub reservations: Option<serde_json::Value>,
}

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

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

/// `MagicLanStaticAddressing` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLanStaticAddressing {
    /// address property.
    pub address: MagicCidr,
    /// dhcp_relay property.
    pub dhcp_relay: Option<MagicLanDhcpRelay>,
    /// dhcp_server property.
    pub dhcp_server: Option<MagicLanDhcpServer>,
    /// secondary_address property.
    pub secondary_address: Option<MagicCidr>,
    /// virtual_address property.
    pub virtual_address: Option<MagicCidr>,
}

/// `MagicLanUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLanUpdateRequest {
    /// bond_id property.
    pub bond_id: Option<MagicBondId>,
    /// is_breakout property.
    pub is_breakout: Option<bool>,
    /// is_prioritized property.
    pub is_prioritized: Option<bool>,
    /// name property.
    pub name: Option<String>,
    /// nat property.
    pub nat: Option<MagicNat>,
    /// physport property.
    pub physport: Option<MagicPort>,
    /// routed_subnets property.
    pub routed_subnets: Option<Vec<MagicRoutedSubnet>>,
    /// static_addressing property.
    pub static_addressing: Option<MagicLanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

/// `MagicLansAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicLansAddSingleRequest {
    /// bond_id property.
    pub bond_id: Option<MagicBondId>,
    /// ha_link property.
    pub ha_link: Option<bool>,
    /// is_breakout property.
    pub is_breakout: Option<bool>,
    /// is_prioritized property.
    pub is_prioritized: Option<bool>,
    /// name property.
    pub name: Option<String>,
    /// nat property.
    pub nat: Option<MagicNat>,
    /// physport property.
    pub physport: Option<MagicPort>,
    /// routed_subnets property.
    pub routed_subnets: Option<Vec<MagicRoutedSubnet>>,
    /// static_addressing property.
    pub static_addressing: Option<MagicLanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

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

/// `MagicManagedApp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicManagedApp {
    /// hostnames property.
    pub hostnames: Option<Vec<String>>,
    /// ip_subnets property.
    pub ip_subnets: Option<Vec<serde_json::Value>>,
    /// managed_app_id property.
    pub managed_app_id: MagicManagedAppId,
    /// name property.
    pub name: Option<MagicAppName>,
    /// source_subnets property.
    pub source_subnets: Option<Vec<serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<MagicAppType>,
}

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

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

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

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

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

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

/// `MagicNetflowConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetflowConfig {
    /// active_timeout property.
    pub active_timeout: Option<i64>,
    /// collector_ip property.
    pub collector_ip: String,
    /// collector_port property.
    pub collector_port: Option<i64>,
    /// inactive_timeout property.
    pub inactive_timeout: Option<i64>,
    /// sampling_rate property.
    pub sampling_rate: Option<i64>,
}

/// `MagicNetflowConfigRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetflowConfigRequest {
    /// active_timeout property.
    pub active_timeout: Option<i64>,
    /// collector_ip property.
    pub collector_ip: Option<String>,
    /// collector_port property.
    pub collector_port: Option<i64>,
    /// inactive_timeout property.
    pub inactive_timeout: Option<i64>,
    /// sampling_rate property.
    pub sampling_rate: Option<i64>,
}

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

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

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

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

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

/// `MagicRoute` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicRoute {
    /// created_on property.
    pub created_on: Option<MagicCreatedOn>,
    /// description property.
    pub description: Option<MagicDescription>,
    /// id property.
    pub id: MagicIdentifier,
    /// modified_on property.
    pub modified_on: Option<MagicModifiedOn>,
    /// nexthop property.
    pub nexthop: MagicNexthop,
    /// prefix property.
    pub prefix: MagicPrefix,
    /// priority property.
    pub priority: MagicPriority,
    /// scope property.
    pub scope: Option<MagicScope>,
    /// weight property.
    pub weight: Option<MagicWeight>,
}

/// `MagicRouteAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicRouteAddSingleRequest {
    /// description property.
    pub description: Option<MagicDescription>,
    /// nexthop property.
    pub nexthop: MagicNexthop,
    /// prefix property.
    pub prefix: MagicPrefix,
    /// priority property.
    pub priority: MagicPriority,
    /// scope property.
    pub scope: Option<MagicScope>,
    /// weight property.
    pub weight: Option<MagicWeight>,
}

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

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

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

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

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

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

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

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

/// `MagicRoutedSubnet` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicRoutedSubnet {
    /// nat property.
    pub nat: Option<MagicNat>,
    /// next_hop property.
    pub next_hop: MagicIpAddress,
    /// prefix property.
    pub prefix: MagicCidr,
}

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

/// `MagicScope` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicScope {
    /// colo_names property.
    pub colo_names: Option<Vec<MagicColoName>>,
    /// colo_regions property.
    pub colo_regions: Option<Vec<MagicColoRegion>>,
}

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

/// `MagicSite` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicSite {
    /// connector_id property.
    pub connector_id: Option<MagicConnectorId>,
    /// description property.
    pub description: Option<String>,
    /// ha_mode property.
    pub ha_mode: Option<bool>,
    /// id property.
    pub id: Option<MagicIdentifier>,
    /// location property.
    pub location: Option<MagicSiteLocation>,
    /// name property.
    pub name: Option<MagicSiteName>,
    /// secondary_connector_id property.
    pub secondary_connector_id: Option<MagicSecondaryConnectorId>,
}

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

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

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

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

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

/// `MagicSiteUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicSiteUpdateRequest {
    /// connector_id property.
    pub connector_id: Option<MagicConnectorId>,
    /// description property.
    pub description: Option<String>,
    /// location property.
    pub location: Option<MagicSiteLocation>,
    /// name property.
    pub name: Option<MagicSiteName>,
    /// secondary_connector_id property.
    pub secondary_connector_id: Option<MagicSecondaryConnectorId>,
}

/// `MagicSitesAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicSitesAddSingleRequest {
    /// connector_id property.
    pub connector_id: Option<MagicConnectorId>,
    /// description property.
    pub description: Option<String>,
    /// ha_mode property.
    pub ha_mode: Option<bool>,
    /// location property.
    pub location: Option<MagicSiteLocation>,
    /// name property.
    pub name: MagicSiteName,
    /// secondary_connector_id property.
    pub secondary_connector_id: Option<MagicSecondaryConnectorId>,
}

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

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

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

/// `MagicWan` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicWan {
    /// health_check_rate property.
    pub health_check_rate: Option<String>,
    /// id property.
    pub id: Option<MagicIdentifier>,
    /// name property.
    pub name: Option<String>,
    /// physport property.
    pub physport: Option<MagicPort>,
    /// priority property.
    pub priority: Option<i64>,
    /// site_id property.
    pub site_id: Option<MagicIdentifier>,
    /// static_addressing property.
    pub static_addressing: Option<MagicWanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

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

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

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

/// `MagicWanStaticAddressing` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicWanStaticAddressing {
    /// address property.
    pub address: MagicCidr,
    /// gateway_address property.
    pub gateway_address: MagicIpAddress,
    /// secondary_address property.
    pub secondary_address: Option<MagicCidr>,
}

/// `MagicWanUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicWanUpdateRequest {
    /// name property.
    pub name: Option<String>,
    /// physport property.
    pub physport: Option<MagicPort>,
    /// priority property.
    pub priority: Option<i64>,
    /// static_addressing property.
    pub static_addressing: Option<MagicWanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

/// `MagicWansAddSingleRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicWansAddSingleRequest {
    /// name property.
    pub name: Option<String>,
    /// physport property.
    pub physport: MagicPort,
    /// priority property.
    pub priority: Option<i64>,
    /// static_addressing property.
    pub static_addressing: Option<MagicWanStaticAddressing>,
    /// vlan_tag property.
    pub vlan_tag: Option<MagicVlanTag>,
}

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

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

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

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

/// `McnAzureSetup` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnAzureSetup {
    /// azure_consent_url property.
    pub azure_consent_url: String,
    /// integration_identity_tag property.
    pub integration_identity_tag: String,
    /// item_type property.
    pub item_type: String,
    /// tag_cli_command property.
    pub tag_cli_command: String,
}

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

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

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

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

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

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

/// `McnCostDiff` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnCostDiff {
    /// currency property.
    pub currency: String,
    /// current_monthly_cost property.
    pub current_monthly_cost: f64,
    /// diff property.
    pub diff: f64,
    /// proposed_monthly_cost property.
    pub proposed_monthly_cost: f64,
}

/// `McnCreateOnrampRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnCreateOnrampRequest {
    /// adopted_hub_id property.
    pub adopted_hub_id: Option<McnResourceId>,
    /// attached_hubs property.
    pub attached_hubs: Option<Vec<McnResourceId>>,
    /// attached_vpcs property.
    pub attached_vpcs: Option<Vec<McnResourceId>>,
    /// cloud_asn property.
    pub cloud_asn: Option<i64>,
    /// cloud_type property.
    pub cloud_type: McnOnrampCloudType,
    /// description property.
    pub description: Option<String>,
    /// dynamic_routing property.
    pub dynamic_routing: bool,
    /// hub_provider_id property.
    pub hub_provider_id: Option<McnProviderId>,
    /// install_routes_in_cloud property.
    pub install_routes_in_cloud: bool,
    /// install_routes_in_magic_wan property.
    pub install_routes_in_magic_wan: bool,
    /// manage_hub_to_hub_attachments property.
    pub manage_hub_to_hub_attachments: Option<bool>,
    /// manage_vpc_to_hub_attachments property.
    pub manage_vpc_to_hub_attachments: Option<bool>,
    /// name property.
    pub name: String,
    /// region property.
    pub region: Option<String>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: McnOnrampType,
    /// vpc property.
    pub vpc: Option<McnResourceId>,
}

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

/// `McnCreateProviderRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnCreateProviderRequest {
    /// cloud_type property.
    pub cloud_type: McnCloudType,
    /// description property.
    pub description: Option<String>,
    /// friendly_name property.
    pub friendly_name: String,
}

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

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

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

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

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

/// `McnError` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnError {
    /// code property.
    pub code: i64,
    /// documentation_url property.
    pub documentation_url: Option<String>,
    /// message property.
    pub message: String,
    /// meta property.
    pub meta: Option<McnErrorMeta>,
    /// source property.
    pub source: Option<McnErrorSource>,
}

/// `McnErrorMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnErrorMeta {
    /// l10n_key property.
    pub l10n_key: Option<String>,
    /// loggable_error property.
    pub loggable_error: Option<String>,
    /// template_data property.
    pub template_data: Option<serde_json::Value>,
    /// trace_id property.
    pub trace_id: Option<String>,
}

/// `McnErrorSource` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnErrorSource {
    /// parameter property.
    pub parameter: Option<String>,
    /// parameter_value_index property.
    pub parameter_value_index: Option<i64>,
    /// pointer property.
    pub pointer: Option<String>,
}

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

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

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

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

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

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

/// `McnOnramp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnOnramp {
    /// attached_hubs property.
    pub attached_hubs: Option<Vec<McnResourceId>>,
    /// attached_vpcs property.
    pub attached_vpcs: Option<Vec<McnResourceId>>,
    /// cloud_asn property.
    pub cloud_asn: Option<i64>,
    /// cloud_type property.
    pub cloud_type: McnOnrampCloudType,
    /// description property.
    pub description: Option<String>,
    /// dynamic_routing property.
    pub dynamic_routing: bool,
    /// hub property.
    pub hub: Option<McnResourceId>,
    /// id property.
    pub id: McnOnrampId,
    /// install_routes_in_cloud property.
    pub install_routes_in_cloud: bool,
    /// install_routes_in_magic_wan property.
    pub install_routes_in_magic_wan: bool,
    /// last_applied_at property.
    pub last_applied_at: Option<String>,
    /// last_exported_at property.
    pub last_exported_at: Option<String>,
    /// last_planned_at property.
    pub last_planned_at: Option<String>,
    /// manage_hub_to_hub_attachments property.
    pub manage_hub_to_hub_attachments: Option<bool>,
    /// manage_vpc_to_hub_attachments property.
    pub manage_vpc_to_hub_attachments: Option<bool>,
    /// name property.
    pub name: String,
    /// planned_monthly_cost_estimate property.
    pub planned_monthly_cost_estimate: Option<McnCostDiff>,
    /// planned_resources property.
    pub planned_resources: Option<Vec<McnResourceDiff>>,
    /// planned_resources_unavailable property.
    pub planned_resources_unavailable: Option<bool>,
    /// post_apply_monthly_cost_estimate property.
    pub post_apply_monthly_cost_estimate: Option<McnCost>,
    /// post_apply_resources property.
    pub post_apply_resources: Option<serde_json::Value>,
    /// post_apply_resources_unavailable property.
    pub post_apply_resources_unavailable: Option<bool>,
    /// region property.
    pub region: Option<String>,
    /// status property.
    pub status: Option<McnOnrampStatus>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: McnOnrampType,
    /// updated_at property.
    pub updated_at: String,
    /// vpc property.
    pub vpc: Option<McnResourceId>,
    /// vpcs_by_id property.
    pub vpcs_by_id: Option<serde_json::Value>,
    /// vpcs_by_id_unavailable property.
    pub vpcs_by_id_unavailable: Option<Vec<McnResourceId>>,
}

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

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

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

/// `McnOnrampStatus` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnOnrampStatus {
    /// apply_progress property.
    pub apply_progress: McnApplyProgress,
    /// lifecycle_errors property.
    pub lifecycle_errors: Option<serde_json::Value>,
    /// lifecycle_state property.
    pub lifecycle_state: McnOnrampLifecycleState,
    /// plan_progress property.
    pub plan_progress: McnPlanProgress,
    /// routes property.
    pub routes: Vec<McnConduitRouteId>,
    /// tunnels property.
    pub tunnels: Vec<McnConduitTunnelId>,
}

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

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

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

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

/// `McnProvider` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnProvider {
    /// aws_arn property.
    pub aws_arn: Option<String>,
    /// azure_subscription_id property.
    pub azure_subscription_id: Option<String>,
    /// azure_tenant_id property.
    pub azure_tenant_id: Option<String>,
    /// cloud_type property.
    pub cloud_type: McnCloudType,
    /// description property.
    pub description: Option<String>,
    /// friendly_name property.
    pub friendly_name: String,
    /// gcp_project_id property.
    pub gcp_project_id: Option<String>,
    /// gcp_service_account_email property.
    pub gcp_service_account_email: Option<String>,
    /// id property.
    pub id: McnProviderId,
    /// last_updated property.
    pub last_updated: String,
    /// lifecycle_state property.
    pub lifecycle_state: McnProviderLifecycleState,
    /// state property.
    pub state: McnProviderDiscoveryStatus,
    /// state_v2 property.
    pub state_v2: McnProviderDiscoveryStatus,
    /// status property.
    pub status: Option<McnProviderStatus>,
}

/// `McnProviderDiscoveryProgress` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnProviderDiscoveryProgress {
    /// done property.
    pub done: i64,
    /// total property.
    pub total: i64,
    /// unit property.
    pub unit: String,
}

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

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

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

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

/// `McnProviderStatus` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnProviderStatus {
    /// credentials_good_since property.
    pub credentials_good_since: Option<String>,
    /// credentials_missing_since property.
    pub credentials_missing_since: Option<String>,
    /// credentials_rejected_since property.
    pub credentials_rejected_since: Option<String>,
    /// discovery_message property.
    pub discovery_message: Option<String>,
    /// discovery_message_v2 property.
    pub discovery_message_v2: Option<String>,
    /// discovery_progress property.
    pub discovery_progress: McnProviderDiscoveryProgress,
    /// discovery_progress_v2 property.
    pub discovery_progress_v2: McnProviderDiscoveryProgress,
    /// in_use_by property.
    pub in_use_by: Option<Vec<McnCloudPlatformClient>>,
    /// last_discovery_completed_at property.
    pub last_discovery_completed_at: Option<String>,
    /// last_discovery_completed_at_v2 property.
    pub last_discovery_completed_at_v2: Option<String>,
    /// last_discovery_started_at property.
    pub last_discovery_started_at: Option<String>,
    /// last_discovery_started_at_v2 property.
    pub last_discovery_started_at_v2: Option<String>,
    /// last_discovery_status property.
    pub last_discovery_status: McnProviderDiscoveryStatus,
    /// last_discovery_status_v2 property.
    pub last_discovery_status_v2: McnProviderDiscoveryStatus,
    /// last_updated property.
    pub last_updated: Option<String>,
    /// regions property.
    pub regions: Vec<String>,
}

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

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

/// `McnResourceDiff` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnResourceDiff {
    /// diff property.
    pub diff: McnYamlDiff,
    /// keys_require_replace property.
    pub keys_require_replace: Vec<String>,
    /// monthly_cost_estimate_diff property.
    pub monthly_cost_estimate_diff: McnCostDiff,
    /// planned_action property.
    pub planned_action: McnPlannedAction,
    /// resource property.
    pub resource: McnResourcePreview,
}

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

/// `McnResourcePreview` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnResourcePreview {
    /// cloud_type property.
    pub cloud_type: McnCloudType,
    /// detail property.
    pub detail: String,
    /// id property.
    pub id: McnResourceId,
    /// name property.
    pub name: String,
    /// resource_type property.
    pub resource_type: McnResourceType,
    /// title property.
    pub title: String,
}

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

/// `McnResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnResponse {
    /// messages property.
    pub messages: Vec<McnError>,
    /// success property.
    pub success: bool,
}

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

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

/// `McnUpdateOnrampRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnUpdateOnrampRequest {
    /// attached_hubs property.
    pub attached_hubs: Option<Vec<McnResourceId>>,
    /// attached_vpcs property.
    pub attached_vpcs: Option<Vec<McnResourceId>>,
    /// description property.
    pub description: Option<String>,
    /// install_routes_in_cloud property.
    pub install_routes_in_cloud: Option<bool>,
    /// install_routes_in_magic_wan property.
    pub install_routes_in_magic_wan: Option<bool>,
    /// manage_hub_to_hub_attachments property.
    pub manage_hub_to_hub_attachments: Option<bool>,
    /// manage_vpc_to_hub_attachments property.
    pub manage_vpc_to_hub_attachments: Option<bool>,
    /// name property.
    pub name: Option<String>,
    /// vpc property.
    pub vpc: Option<McnResourceId>,
}

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

/// `McnUpdateProviderRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnUpdateProviderRequest {
    /// aws_arn property.
    pub aws_arn: Option<String>,
    /// azure_subscription_id property.
    pub azure_subscription_id: Option<String>,
    /// azure_tenant_id property.
    pub azure_tenant_id: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// friendly_name property.
    pub friendly_name: Option<String>,
    /// gcp_project_id property.
    pub gcp_project_id: Option<String>,
    /// gcp_service_account_email property.
    pub gcp_service_account_email: Option<String>,
}

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

/// `McnYamlDiff` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McnYamlDiff {
    /// diff property.
    pub diff: String,
    /// left_description property.
    pub left_description: String,
    /// left_yaml property.
    pub left_yaml: String,
    /// right_description property.
    pub right_description: String,
    /// right_yaml property.
    pub right_yaml: String,
}

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

/// `MconnCustomerConnector` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerConnector {
    /// activated property.
    pub activated: bool,
    /// device property.
    pub device: Option<MconnCustomerDevice>,
    /// id property.
    pub id: MconnUuid,
    /// interrupt_window_days_of_week property.
    pub interrupt_window_days_of_week: Vec<MconnDayOfWeek>,
    /// interrupt_window_duration_hours property.
    pub interrupt_window_duration_hours: f64,
    /// interrupt_window_embargo_dates property.
    pub interrupt_window_embargo_dates: Vec<MconnEmbargoDate>,
    /// interrupt_window_hour_of_day property.
    pub interrupt_window_hour_of_day: f64,
    /// last_heartbeat property.
    pub last_heartbeat: Option<String>,
    /// last_seen_version property.
    pub last_seen_version: Option<String>,
    /// last_updated property.
    pub last_updated: String,
    /// license_key property.
    pub license_key: Option<String>,
    /// notes property.
    pub notes: String,
    /// timezone property.
    pub timezone: String,
}

/// `MconnCustomerConnectorCreateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerConnectorCreateRequest {
    /// `device` property.
    pub device: MconnCustomerDeviceOptions,
}

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

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

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

/// `MconnCustomerConnectorFields` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerConnectorFields {
    /// activated property.
    pub activated: Option<bool>,
    /// interrupt_window_days_of_week property.
    pub interrupt_window_days_of_week: Option<Vec<MconnDayOfWeek>>,
    /// interrupt_window_duration_hours property.
    pub interrupt_window_duration_hours: Option<f64>,
    /// interrupt_window_embargo_dates property.
    pub interrupt_window_embargo_dates: Option<Vec<MconnEmbargoDate>>,
    /// interrupt_window_hour_of_day property.
    pub interrupt_window_hour_of_day: Option<f64>,
    /// notes property.
    pub notes: Option<String>,
    /// timezone property.
    pub timezone: Option<String>,
}

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

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

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

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

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

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

/// `MconnCustomerEventsGetLatestResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerEventsGetLatestResult {
    /// count property.
    pub count: f64,
    /// items property.
    pub items: Vec<MconnRecordedEvent>,
}

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

/// `MconnCustomerEventsGetResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerEventsGetResult {
    /// count property.
    pub count: f64,
    /// cursor property.
    pub cursor: Option<String>,
    /// items property.
    pub items: Vec<MconnEventMetadata>,
}

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

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

/// `MconnCustomerSnapshotsGetLatestResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerSnapshotsGetLatestResult {
    /// count property.
    pub count: f64,
    /// items property.
    pub items: Vec<MconnSnapshot>,
}

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

/// `MconnCustomerSnapshotsGetResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnCustomerSnapshotsGetResult {
    /// count property.
    pub count: f64,
    /// cursor property.
    pub cursor: Option<String>,
    /// items property.
    pub items: Vec<MconnSnapshotMetadata>,
}

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

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

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

/// `MconnEnvelope` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnEnvelope {
    /// errors property.
    pub errors: Option<Vec<MconnCodedMessage>>,
    /// messages property.
    pub messages: Option<Vec<MconnCodedMessage>>,
    /// success property.
    pub success: bool,
}

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

/// `MconnEventMetadata` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnEventMetadata {
    /// a property.
    pub a: f64,
    /// k property.
    pub k: String,
    /// n property.
    pub n: f64,
    /// t property.
    pub t: f64,
}

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

/// `MconnRecordedEvent` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnRecordedEvent {
    /// e property.
    pub e: MconnEvent,
    /// n property.
    pub n: f64,
    /// t property.
    pub t: f64,
    /// v property.
    pub v: Option<String>,
}

/// `MconnResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnResponse {
    /// messages property.
    pub messages: Vec<MconnCodedMessage>,
    /// success property.
    pub success: bool,
}

/// `MconnSnapshot` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshot {
    /// bonds property.
    pub bonds: Option<Vec<MconnSnapshotBond>>,
    /// count_reclaim_failures property.
    pub count_reclaim_failures: f64,
    /// count_reclaimed_paths property.
    pub count_reclaimed_paths: f64,
    /// count_record_failed property.
    pub count_record_failed: f64,
    /// count_transmit_failures property.
    pub count_transmit_failures: f64,
    /// cpu_count property.
    pub cpu_count: Option<f64>,
    /// cpu_pressure_10s property.
    pub cpu_pressure_10s: Option<f64>,
    /// cpu_pressure_300s property.
    pub cpu_pressure_300s: Option<f64>,
    /// cpu_pressure_60s property.
    pub cpu_pressure_60s: Option<f64>,
    /// cpu_pressure_total_us property.
    pub cpu_pressure_total_us: Option<f64>,
    /// cpu_time_guest_ms property.
    pub cpu_time_guest_ms: Option<f64>,
    /// cpu_time_guest_nice_ms property.
    pub cpu_time_guest_nice_ms: Option<f64>,
    /// cpu_time_idle_ms property.
    pub cpu_time_idle_ms: Option<f64>,
    /// cpu_time_iowait_ms property.
    pub cpu_time_iowait_ms: Option<f64>,
    /// cpu_time_irq_ms property.
    pub cpu_time_irq_ms: Option<f64>,
    /// cpu_time_nice_ms property.
    pub cpu_time_nice_ms: Option<f64>,
    /// cpu_time_softirq_ms property.
    pub cpu_time_softirq_ms: Option<f64>,
    /// cpu_time_steal_ms property.
    pub cpu_time_steal_ms: Option<f64>,
    /// cpu_time_system_ms property.
    pub cpu_time_system_ms: Option<f64>,
    /// cpu_time_user_ms property.
    pub cpu_time_user_ms: Option<f64>,
    /// delta property.
    pub delta: Option<f64>,
    /// dhcp_leases property.
    pub dhcp_leases: Option<Vec<MconnSnapshotDhcpLease>>,
    /// disks property.
    pub disks: Option<Vec<MconnSnapshotDisk>>,
    /// epsilon property.
    pub epsilon: Option<f64>,
    /// ha_state property.
    pub ha_state: Option<String>,
    /// ha_value property.
    pub ha_value: Option<f64>,
    /// interfaces property.
    pub interfaces: Option<Vec<MconnSnapshotInterface>>,
    /// io_pressure_full_10s property.
    pub io_pressure_full_10s: Option<f64>,
    /// io_pressure_full_300s property.
    pub io_pressure_full_300s: Option<f64>,
    /// io_pressure_full_60s property.
    pub io_pressure_full_60s: Option<f64>,
    /// io_pressure_full_total_us property.
    pub io_pressure_full_total_us: Option<f64>,
    /// io_pressure_some_10s property.
    pub io_pressure_some_10s: Option<f64>,
    /// io_pressure_some_300s property.
    pub io_pressure_some_300s: Option<f64>,
    /// io_pressure_some_60s property.
    pub io_pressure_some_60s: Option<f64>,
    /// io_pressure_some_total_us property.
    pub io_pressure_some_total_us: Option<f64>,
    /// kernel_btime property.
    pub kernel_btime: Option<f64>,
    /// kernel_ctxt property.
    pub kernel_ctxt: Option<f64>,
    /// kernel_processes property.
    pub kernel_processes: Option<f64>,
    /// kernel_processes_blocked property.
    pub kernel_processes_blocked: Option<f64>,
    /// kernel_processes_running property.
    pub kernel_processes_running: Option<f64>,
    /// load_average_15m property.
    pub load_average_15m: Option<f64>,
    /// load_average_1m property.
    pub load_average_1m: Option<f64>,
    /// load_average_5m property.
    pub load_average_5m: Option<f64>,
    /// load_average_cur property.
    pub load_average_cur: Option<f64>,
    /// load_average_max property.
    pub load_average_max: Option<f64>,
    /// memory_active_bytes property.
    pub memory_active_bytes: Option<f64>,
    /// memory_anon_hugepages_bytes property.
    pub memory_anon_hugepages_bytes: Option<f64>,
    /// memory_anon_pages_bytes property.
    pub memory_anon_pages_bytes: Option<f64>,
    /// memory_available_bytes property.
    pub memory_available_bytes: Option<f64>,
    /// memory_bounce_bytes property.
    pub memory_bounce_bytes: Option<f64>,
    /// memory_buffers_bytes property.
    pub memory_buffers_bytes: Option<f64>,
    /// memory_cached_bytes property.
    pub memory_cached_bytes: Option<f64>,
    /// memory_cma_free_bytes property.
    pub memory_cma_free_bytes: Option<f64>,
    /// memory_cma_total_bytes property.
    pub memory_cma_total_bytes: Option<f64>,
    /// memory_commit_limit_bytes property.
    pub memory_commit_limit_bytes: Option<f64>,
    /// memory_committed_as_bytes property.
    pub memory_committed_as_bytes: Option<f64>,
    /// memory_dirty_bytes property.
    pub memory_dirty_bytes: Option<f64>,
    /// memory_free_bytes property.
    pub memory_free_bytes: Option<f64>,
    /// memory_high_free_bytes property.
    pub memory_high_free_bytes: Option<f64>,
    /// memory_high_total_bytes property.
    pub memory_high_total_bytes: Option<f64>,
    /// memory_hugepages_free property.
    pub memory_hugepages_free: Option<f64>,
    /// memory_hugepages_rsvd property.
    pub memory_hugepages_rsvd: Option<f64>,
    /// memory_hugepages_surp property.
    pub memory_hugepages_surp: Option<f64>,
    /// memory_hugepages_total property.
    pub memory_hugepages_total: Option<f64>,
    /// memory_hugepagesize_bytes property.
    pub memory_hugepagesize_bytes: Option<f64>,
    /// memory_inactive_bytes property.
    pub memory_inactive_bytes: Option<f64>,
    /// memory_k_reclaimable_bytes property.
    pub memory_k_reclaimable_bytes: Option<f64>,
    /// memory_kernel_stack_bytes property.
    pub memory_kernel_stack_bytes: Option<f64>,
    /// memory_low_free_bytes property.
    pub memory_low_free_bytes: Option<f64>,
    /// memory_low_total_bytes property.
    pub memory_low_total_bytes: Option<f64>,
    /// memory_mapped_bytes property.
    pub memory_mapped_bytes: Option<f64>,
    /// memory_page_tables_bytes property.
    pub memory_page_tables_bytes: Option<f64>,
    /// memory_per_cpu_bytes property.
    pub memory_per_cpu_bytes: Option<f64>,
    /// memory_pressure_full_10s property.
    pub memory_pressure_full_10s: Option<f64>,
    /// memory_pressure_full_300s property.
    pub memory_pressure_full_300s: Option<f64>,
    /// memory_pressure_full_60s property.
    pub memory_pressure_full_60s: Option<f64>,
    /// memory_pressure_full_total_us property.
    pub memory_pressure_full_total_us: Option<f64>,
    /// memory_pressure_some_10s property.
    pub memory_pressure_some_10s: Option<f64>,
    /// memory_pressure_some_300s property.
    pub memory_pressure_some_300s: Option<f64>,
    /// memory_pressure_some_60s property.
    pub memory_pressure_some_60s: Option<f64>,
    /// memory_pressure_some_total_us property.
    pub memory_pressure_some_total_us: Option<f64>,
    /// memory_s_reclaimable_bytes property.
    pub memory_s_reclaimable_bytes: Option<f64>,
    /// memory_s_unreclaim_bytes property.
    pub memory_s_unreclaim_bytes: Option<f64>,
    /// memory_secondary_page_tables_bytes property.
    pub memory_secondary_page_tables_bytes: Option<f64>,
    /// memory_shmem_bytes property.
    pub memory_shmem_bytes: Option<f64>,
    /// memory_shmem_hugepages_bytes property.
    pub memory_shmem_hugepages_bytes: Option<f64>,
    /// memory_shmem_pmd_mapped_bytes property.
    pub memory_shmem_pmd_mapped_bytes: Option<f64>,
    /// memory_slab_bytes property.
    pub memory_slab_bytes: Option<f64>,
    /// memory_swap_cached_bytes property.
    pub memory_swap_cached_bytes: Option<f64>,
    /// memory_swap_free_bytes property.
    pub memory_swap_free_bytes: Option<f64>,
    /// memory_swap_total_bytes property.
    pub memory_swap_total_bytes: Option<f64>,
    /// memory_total_bytes property.
    pub memory_total_bytes: Option<f64>,
    /// memory_vmalloc_chunk_bytes property.
    pub memory_vmalloc_chunk_bytes: Option<f64>,
    /// memory_vmalloc_total_bytes property.
    pub memory_vmalloc_total_bytes: Option<f64>,
    /// memory_vmalloc_used_bytes property.
    pub memory_vmalloc_used_bytes: Option<f64>,
    /// memory_writeback_bytes property.
    pub memory_writeback_bytes: Option<f64>,
    /// memory_writeback_tmp_bytes property.
    pub memory_writeback_tmp_bytes: Option<f64>,
    /// memory_z_swap_bytes property.
    pub memory_z_swap_bytes: Option<f64>,
    /// memory_z_swapped_bytes property.
    pub memory_z_swapped_bytes: Option<f64>,
    /// mounts property.
    pub mounts: Option<Vec<MconnSnapshotMount>>,
    /// netdevs property.
    pub netdevs: Option<Vec<MconnSnapshotNetdev>>,
    /// platform property.
    pub platform: Option<String>,
    /// snmp_icmp_in_addr_mask_reps property.
    pub snmp_icmp_in_addr_mask_reps: Option<f64>,
    /// snmp_icmp_in_addr_masks property.
    pub snmp_icmp_in_addr_masks: Option<f64>,
    /// snmp_icmp_in_csum_errors property.
    pub snmp_icmp_in_csum_errors: Option<f64>,
    /// snmp_icmp_in_dest_unreachs property.
    pub snmp_icmp_in_dest_unreachs: Option<f64>,
    /// snmp_icmp_in_echo_reps property.
    pub snmp_icmp_in_echo_reps: Option<f64>,
    /// snmp_icmp_in_echos property.
    pub snmp_icmp_in_echos: Option<f64>,
    /// snmp_icmp_in_errors property.
    pub snmp_icmp_in_errors: Option<f64>,
    /// snmp_icmp_in_msgs property.
    pub snmp_icmp_in_msgs: Option<f64>,
    /// snmp_icmp_in_parm_probs property.
    pub snmp_icmp_in_parm_probs: Option<f64>,
    /// snmp_icmp_in_redirects property.
    pub snmp_icmp_in_redirects: Option<f64>,
    /// snmp_icmp_in_src_quenchs property.
    pub snmp_icmp_in_src_quenchs: Option<f64>,
    /// snmp_icmp_in_time_excds property.
    pub snmp_icmp_in_time_excds: Option<f64>,
    /// snmp_icmp_in_timestamp_reps property.
    pub snmp_icmp_in_timestamp_reps: Option<f64>,
    /// snmp_icmp_in_timestamps property.
    pub snmp_icmp_in_timestamps: Option<f64>,
    /// snmp_icmp_out_addr_mask_reps property.
    pub snmp_icmp_out_addr_mask_reps: Option<f64>,
    /// snmp_icmp_out_addr_masks property.
    pub snmp_icmp_out_addr_masks: Option<f64>,
    /// snmp_icmp_out_dest_unreachs property.
    pub snmp_icmp_out_dest_unreachs: Option<f64>,
    /// snmp_icmp_out_echo_reps property.
    pub snmp_icmp_out_echo_reps: Option<f64>,
    /// snmp_icmp_out_echos property.
    pub snmp_icmp_out_echos: Option<f64>,
    /// snmp_icmp_out_errors property.
    pub snmp_icmp_out_errors: Option<f64>,
    /// snmp_icmp_out_msgs property.
    pub snmp_icmp_out_msgs: Option<f64>,
    /// snmp_icmp_out_parm_probs property.
    pub snmp_icmp_out_parm_probs: Option<f64>,
    /// snmp_icmp_out_redirects property.
    pub snmp_icmp_out_redirects: Option<f64>,
    /// snmp_icmp_out_src_quenchs property.
    pub snmp_icmp_out_src_quenchs: Option<f64>,
    /// snmp_icmp_out_time_excds property.
    pub snmp_icmp_out_time_excds: Option<f64>,
    /// snmp_icmp_out_timestamp_reps property.
    pub snmp_icmp_out_timestamp_reps: Option<f64>,
    /// snmp_icmp_out_timestamps property.
    pub snmp_icmp_out_timestamps: Option<f64>,
    /// snmp_ip_default_ttl property.
    pub snmp_ip_default_ttl: Option<f64>,
    /// snmp_ip_forw_datagrams property.
    pub snmp_ip_forw_datagrams: Option<f64>,
    /// snmp_ip_forwarding_enabled property.
    pub snmp_ip_forwarding_enabled: Option<bool>,
    /// snmp_ip_frag_creates property.
    pub snmp_ip_frag_creates: Option<f64>,
    /// snmp_ip_frag_fails property.
    pub snmp_ip_frag_fails: Option<f64>,
    /// snmp_ip_frag_oks property.
    pub snmp_ip_frag_oks: Option<f64>,
    /// snmp_ip_in_addr_errors property.
    pub snmp_ip_in_addr_errors: Option<f64>,
    /// snmp_ip_in_delivers property.
    pub snmp_ip_in_delivers: Option<f64>,
    /// snmp_ip_in_discards property.
    pub snmp_ip_in_discards: Option<f64>,
    /// snmp_ip_in_hdr_errors property.
    pub snmp_ip_in_hdr_errors: Option<f64>,
    /// snmp_ip_in_receives property.
    pub snmp_ip_in_receives: Option<f64>,
    /// snmp_ip_in_unknown_protos property.
    pub snmp_ip_in_unknown_protos: Option<f64>,
    /// snmp_ip_out_discards property.
    pub snmp_ip_out_discards: Option<f64>,
    /// snmp_ip_out_no_routes property.
    pub snmp_ip_out_no_routes: Option<f64>,
    /// snmp_ip_out_requests property.
    pub snmp_ip_out_requests: Option<f64>,
    /// snmp_ip_reasm_fails property.
    pub snmp_ip_reasm_fails: Option<f64>,
    /// snmp_ip_reasm_oks property.
    pub snmp_ip_reasm_oks: Option<f64>,
    /// snmp_ip_reasm_reqds property.
    pub snmp_ip_reasm_reqds: Option<f64>,
    /// snmp_ip_reasm_timeout property.
    pub snmp_ip_reasm_timeout: Option<f64>,
    /// snmp_tcp_active_opens property.
    pub snmp_tcp_active_opens: Option<f64>,
    /// snmp_tcp_attempt_fails property.
    pub snmp_tcp_attempt_fails: Option<f64>,
    /// snmp_tcp_curr_estab property.
    pub snmp_tcp_curr_estab: Option<f64>,
    /// snmp_tcp_estab_resets property.
    pub snmp_tcp_estab_resets: Option<f64>,
    /// snmp_tcp_in_csum_errors property.
    pub snmp_tcp_in_csum_errors: Option<f64>,
    /// snmp_tcp_in_errs property.
    pub snmp_tcp_in_errs: Option<f64>,
    /// snmp_tcp_in_segs property.
    pub snmp_tcp_in_segs: Option<f64>,
    /// snmp_tcp_max_conn property.
    pub snmp_tcp_max_conn: Option<f64>,
    /// snmp_tcp_out_rsts property.
    pub snmp_tcp_out_rsts: Option<f64>,
    /// snmp_tcp_out_segs property.
    pub snmp_tcp_out_segs: Option<f64>,
    /// snmp_tcp_passive_opens property.
    pub snmp_tcp_passive_opens: Option<f64>,
    /// snmp_tcp_retrans_segs property.
    pub snmp_tcp_retrans_segs: Option<f64>,
    /// snmp_tcp_rto_max property.
    pub snmp_tcp_rto_max: Option<f64>,
    /// snmp_tcp_rto_min property.
    pub snmp_tcp_rto_min: Option<f64>,
    /// snmp_udp_in_datagrams property.
    pub snmp_udp_in_datagrams: Option<f64>,
    /// snmp_udp_in_errors property.
    pub snmp_udp_in_errors: Option<f64>,
    /// snmp_udp_no_ports property.
    pub snmp_udp_no_ports: Option<f64>,
    /// snmp_udp_out_datagrams property.
    pub snmp_udp_out_datagrams: Option<f64>,
    /// system_boot_time_s property.
    pub system_boot_time_s: Option<f64>,
    /// t property.
    pub t: f64,
    /// thermals property.
    pub thermals: Option<Vec<MconnSnapshotThermal>>,
    /// tunnels property.
    pub tunnels: Option<Vec<MconnSnapshotTunnel>>,
    /// uptime_idle_ms property.
    pub uptime_idle_ms: Option<f64>,
    /// uptime_total_ms property.
    pub uptime_total_ms: Option<f64>,
    /// v property.
    pub v: String,
}

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

/// `MconnSnapshotDhcpLease` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotDhcpLease {
    /// client_id property.
    pub client_id: String,
    /// expiry_time property.
    pub expiry_time: f64,
    /// hostname property.
    pub hostname: String,
    /// interface_name property.
    pub interface_name: String,
    /// ip_address property.
    pub ip_address: String,
    /// mac_address property.
    pub mac_address: String,
}

/// `MconnSnapshotDisk` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotDisk {
    /// discards property.
    pub discards: Option<f64>,
    /// discards_merged property.
    pub discards_merged: Option<f64>,
    /// flushes property.
    pub flushes: Option<f64>,
    /// in_progress property.
    pub in_progress: f64,
    /// major property.
    pub major: f64,
    /// merged property.
    pub merged: f64,
    /// minor property.
    pub minor: f64,
    /// name property.
    pub name: String,
    /// reads property.
    pub reads: f64,
    /// sectors_discarded property.
    pub sectors_discarded: Option<f64>,
    /// sectors_read property.
    pub sectors_read: f64,
    /// sectors_written property.
    pub sectors_written: f64,
    /// time_discarding_ms property.
    pub time_discarding_ms: Option<f64>,
    /// time_flushing_ms property.
    pub time_flushing_ms: Option<f64>,
    /// time_in_progress_ms property.
    pub time_in_progress_ms: f64,
    /// time_reading_ms property.
    pub time_reading_ms: f64,
    /// time_writing_ms property.
    pub time_writing_ms: f64,
    /// weighted_time_in_progress_ms property.
    pub weighted_time_in_progress_ms: f64,
    /// writes property.
    pub writes: f64,
    /// writes_merged property.
    pub writes_merged: f64,
}

/// `MconnSnapshotInterface` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotInterface {
    /// ip_addresses property.
    pub ip_addresses: Option<Vec<MconnSnapshotInterfaceAddress>>,
    /// name property.
    pub name: String,
    /// operstate property.
    pub operstate: String,
    /// speed property.
    pub speed: Option<f64>,
}

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

/// `MconnSnapshotMetadata` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotMetadata {
    /// a property.
    pub a: f64,
    /// t property.
    pub t: f64,
}

/// `MconnSnapshotMount` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotMount {
    /// available_bytes property.
    pub available_bytes: Option<f64>,
    /// file_system property.
    pub file_system: String,
    /// is_read_only property.
    pub is_read_only: Option<bool>,
    /// is_removable property.
    pub is_removable: Option<bool>,
    /// kind property.
    pub kind: String,
    /// mount_point property.
    pub mount_point: String,
    /// name property.
    pub name: String,
    /// total_bytes property.
    pub total_bytes: Option<f64>,
}

/// `MconnSnapshotNetdev` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotNetdev {
    /// name property.
    pub name: String,
    /// recv_bytes property.
    pub recv_bytes: f64,
    /// recv_compressed property.
    pub recv_compressed: f64,
    /// recv_drop property.
    pub recv_drop: f64,
    /// recv_errs property.
    pub recv_errs: f64,
    /// recv_fifo property.
    pub recv_fifo: f64,
    /// recv_frame property.
    pub recv_frame: f64,
    /// recv_multicast property.
    pub recv_multicast: f64,
    /// recv_packets property.
    pub recv_packets: f64,
    /// sent_bytes property.
    pub sent_bytes: f64,
    /// sent_carrier property.
    pub sent_carrier: f64,
    /// sent_colls property.
    pub sent_colls: f64,
    /// sent_compressed property.
    pub sent_compressed: f64,
    /// sent_drop property.
    pub sent_drop: f64,
    /// sent_errs property.
    pub sent_errs: f64,
    /// sent_fifo property.
    pub sent_fifo: f64,
    /// sent_packets property.
    pub sent_packets: f64,
}

/// `MconnSnapshotThermal` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotThermal {
    /// critical_celcius property.
    pub critical_celcius: Option<f64>,
    /// current_celcius property.
    pub current_celcius: Option<f64>,
    /// label property.
    pub label: String,
    /// max_celcius property.
    pub max_celcius: Option<f64>,
}

/// `MconnSnapshotTunnel` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MconnSnapshotTunnel {
    /// health_state property.
    pub health_state: String,
    /// health_value property.
    pub health_value: f64,
    /// interface_name property.
    pub interface_name: String,
    /// probed_mtu property.
    pub probed_mtu: Option<f64>,
    /// recent_healthy_pings property.
    pub recent_healthy_pings: Option<f64>,
    /// recent_unhealthy_pings property.
    pub recent_unhealthy_pings: Option<f64>,
    /// tunnel_id property.
    pub tunnel_id: String,
}

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

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

/// Arguments for [`ip-address-management-address-maps-list-address-maps_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsListAddressMapsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-address-maps-create-address-map_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsCreateAddressMapArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IpAddressManagementAddressMapsCreateAddressMapRequest,
}

/// Arguments for [`ip-address-management-address-maps-address-map-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsAddressMapDetailsArgs {
    /// Path parameter: `address_map_id`.
    pub address_map_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-address-maps-update-address-map_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsUpdateAddressMapArgs {
    /// Path parameter: `address_map_id`.
    pub address_map_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IpAddressManagementAddressMapsUpdateAddressMapRequest,
}

/// Arguments for [`ip-address-management-address-maps-delete-address-map_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsDeleteAddressMapArgs {
    /// Path parameter: `address_map_id`.
    pub address_map_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-address-maps-add-an-ip-to-an-address-map_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsAddAnIpToAnAddressMapArgs {
    /// Path parameter: `ip_address`.
    pub ip_address: String,
    /// Path parameter: `address_map_id`.
    pub address_map_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-address-maps-remove-an-ip-from-an-address-map_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementAddressMapsRemoveAnIpFromAnAddressMapArgs {
    /// Path parameter: `ip_address`.
    pub ip_address: String,
    /// Path parameter: `address_map_id`.
    pub address_map_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-list-leases_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementListLeasesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-upload-loa-document_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesUploadLoaDocumentArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-download-loa-document_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesDownloadLoaDocumentArgs {
    /// Path parameter: `loa_document_id`.
    pub loa_document_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-list-prefixes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesListPrefixesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-add-prefix_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesAddPrefixArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IpAddressManagementPrefixesAddPrefixRequest,
}

/// Arguments for [`ip-address-management-prefixes-prefix-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesPrefixDetailsArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-update-prefix-description_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesUpdatePrefixDescriptionArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IpAddressManagementPrefixesUpdatePrefixDescriptionRequest,
}

/// Arguments for [`ip-address-management-prefixes-delete-prefix_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesDeletePrefixArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefix-delegation-list-prefix-delegations_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixDelegationListPrefixDelegationsArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefix-delegation-create-prefix-delegation_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixDelegationCreatePrefixDelegationArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IpAddressManagementPrefixDelegationCreatePrefixDelegationRequest,
}

/// Arguments for [`ip-address-management-prefix-delegation-delete-prefix-delegation_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixDelegationDeletePrefixDelegationArgs {
    /// Path parameter: `delegation_id`.
    pub delegation_id: String,
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`ip-address-management-prefixes-validate-prefix_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct IpAddressManagementPrefixesValidatePrefixArgs {
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`listAllowlistPrefixesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAllowlistPrefixesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

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

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

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

/// Arguments for [`updateAllowlistPrefix_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateAllowlistPrefixArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Request body.
    pub body: DosInfraPrefixUpdate,
}

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

/// Arguments for [`listPrefixesForAccount_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListPrefixesForAccountArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

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

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

/// Arguments for [`bulkCreatePrefixes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct BulkCreatePrefixesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: Vec<DosNewPrefix>,
}

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

/// Arguments for [`updatePrefix_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdatePrefixArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `prefix_id`.
    pub prefix_id: String,
    /// Request body.
    pub body: DosPrefixUpdate,
}

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

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

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

/// Arguments for [`magic-account-apps-list-apps_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicAccountAppsListAppsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-account-apps-add-app_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicAccountAppsAddAppArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicAppAddSingleRequest,
}

/// Arguments for [`magic-account-apps-update-app_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicAccountAppsUpdateAppArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `account_app_id`.
    pub account_app_id: String,
    /// Request body.
    pub body: MagicAppUpdateRequest,
}

/// Arguments for [`magic-account-apps-patch-app_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicAccountAppsPatchAppArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `account_app_id`.
    pub account_app_id: String,
    /// Request body.
    pub body: MagicAppUpdateRequest,
}

/// Arguments for [`magic-account-apps-delete-app_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicAccountAppsDeleteAppArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `account_app_id`.
    pub account_app_id: String,
}

/// Arguments for [`onramps-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `order_by`.
    pub order_by: Option<String>,
    /// Query parameter: `desc`.
    pub desc: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `vpcs`.
    pub vpcs: Option<String>,
}

/// Arguments for [`onramps-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McnCreateOnrampRequest,
}

/// Arguments for [`onramps-mwan-addr-space-read_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsMwanAddrSpaceReadArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`onramps-mwan-addr-space-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsMwanAddrSpaceUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McnUpdateMagicWanAddressSpaceRequest,
}

/// Arguments for [`onramps-mwan-addr-space-patch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsMwanAddrSpacePatchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McnUpdateMagicWanAddressSpaceRequest,
}

/// Arguments for [`onramps-read_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsReadArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `vpcs`.
    pub vpcs: Option<String>,
    /// Query parameter: `post_apply_resources`.
    pub post_apply_resources: Option<String>,
    /// Query parameter: `planned_resources`.
    pub planned_resources: Option<String>,
}

/// Arguments for [`onramps-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
    /// Request body.
    pub body: McnUpdateOnrampRequest,
}

/// Arguments for [`onramps-patch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsPatchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
    /// Request body.
    pub body: McnUpdateOnrampRequest,
}

/// Arguments for [`onramps-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
    /// Query parameter: `destroy`.
    pub destroy: Option<String>,
    /// Query parameter: `force`.
    pub force: Option<String>,
}

/// Arguments for [`onramps-apply_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsApplyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
}

/// Arguments for [`onramps-export_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsExportArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
}

/// Arguments for [`onramps-plan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OnrampsPlanArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `onramp_id`.
    pub onramp_id: String,
}

/// Arguments for [`providers-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `order_by`.
    pub order_by: Option<String>,
    /// Query parameter: `desc`.
    pub desc: Option<String>,
    /// Query parameter: `cloudflare`.
    pub cloudflare: Option<String>,
}

/// Arguments for [`providers-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McnCreateProviderRequest,
}

/// Arguments for [`providers-discover-all_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersDiscoverAllArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`providers-read_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersReadArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
    /// Query parameter: `status`.
    pub status: Option<String>,
}

/// Arguments for [`providers-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
    /// Request body.
    pub body: McnUpdateProviderRequest,
}

/// Arguments for [`providers-patch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersPatchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
    /// Request body.
    pub body: McnUpdateProviderRequest,
}

/// Arguments for [`providers-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
}

/// Arguments for [`providers-discover_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersDiscoverArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
    /// Query parameter: `v2`.
    pub v2: Option<String>,
}

/// Arguments for [`providers-initial-setup_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ProvidersInitialSetupArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `provider_id`.
    pub provider_id: String,
}

/// Arguments for [`mconn-connector-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`mconn-connector-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MconnCustomerConnectorCreateRequest,
}

/// Arguments for [`mconn-connector-fetch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorFetchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
}

/// Arguments for [`mconn-connector-replace_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorReplaceArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Request body.
    pub body: MconnCustomerConnectorUpdateRequest,
}

/// Arguments for [`mconn-connector-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Request body.
    pub body: MconnCustomerConnectorUpdateRequest,
}

/// Arguments for [`mconn-connector-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
}

/// Arguments for [`mconn-connector-telemetry-events-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetryEventsListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Query parameter: `from`.
    pub from: Option<String>,
    /// Query parameter: `to`.
    pub to: Option<String>,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
    /// Query parameter: `k`.
    pub k: Option<String>,
}

/// Arguments for [`mconn-connector-telemetry-events-listLatest_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetryEventsListLatestArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
}

/// Arguments for [`mconn-connector-telemetry-events-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetryEventsGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Path parameter: `event_t`.
    pub event_t: String,
    /// Path parameter: `event_n`.
    pub event_n: String,
}

/// Arguments for [`mconn-connector-telemetry-snapshots-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetrySnapshotsListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Query parameter: `from`.
    pub from: Option<String>,
    /// Query parameter: `to`.
    pub to: Option<String>,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
}

/// Arguments for [`mconn-connector-telemetry-snapshots-listLatest_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetrySnapshotsListLatestArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
}

/// Arguments for [`mconn-connector-telemetry-snapshots-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MconnConnectorTelemetrySnapshotsGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `connector_id`.
    pub connector_id: String,
    /// Path parameter: `snapshot_t`.
    pub snapshot_t: String,
}

/// Arguments for [`magic-static-routes-list-routes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesListRoutesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-static-routes-create-routes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesCreateRoutesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicCreateRouteRequest,
}

/// Arguments for [`magic-static-routes-update-many-routes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesUpdateManyRoutesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicRouteUpdateManyRequest,
}

/// Arguments for [`magic-static-routes-delete-many-routes_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesDeleteManyRoutesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicRouteDeleteManyRequest,
}

/// Arguments for [`magic-static-routes-route-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesRouteDetailsArgs {
    /// Path parameter: `route_id`.
    pub route_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-static-routes-update-route_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesUpdateRouteArgs {
    /// Path parameter: `route_id`.
    pub route_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicRouteUpdateRequest,
}

/// Arguments for [`magic-static-routes-delete-route_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicStaticRoutesDeleteRouteArgs {
    /// Path parameter: `route_id`.
    pub route_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-sites-list-sites_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesListSitesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `connectorid`.
    pub connectorid: Option<String>,
}

/// Arguments for [`magic-sites-create-site_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesCreateSiteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicSitesAddSingleRequest,
}

/// Arguments for [`magic-sites-site-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesSiteDetailsArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-sites-update-site_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesUpdateSiteArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicSiteUpdateRequest,
}

/// Arguments for [`magic-sites-patch-site_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesPatchSiteArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicSiteUpdateRequest,
}

/// Arguments for [`magic-sites-delete-site_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSitesDeleteSiteArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-site-acls-list-acls_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsListAclsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-acls-create-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsCreateAclArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicAclsAddSingleRequest,
}

/// Arguments for [`magic-site-acls-acl-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsAclDetailsArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `acl_id`.
    pub acl_id: String,
}

/// Arguments for [`magic-site-acls-update-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsUpdateAclArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `acl_id`.
    pub acl_id: String,
    /// Request body.
    pub body: MagicAclUpdateRequest,
}

/// Arguments for [`magic-site-acls-patch-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsPatchAclArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `acl_id`.
    pub acl_id: String,
    /// Request body.
    pub body: MagicAclUpdateRequest,
}

/// Arguments for [`magic-site-acls-delete-acl_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAclsDeleteAclArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `acl_id`.
    pub acl_id: String,
}

/// Arguments for [`magic-site-app-configs-list-app-configs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAppConfigsListAppConfigsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-app-configs-add-app-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAppConfigsAddAppConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicAppConfigAddSingleRequest,
}

/// Arguments for [`magic-site-app-configs-update-app-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAppConfigsUpdateAppConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `app_config_id`.
    pub app_config_id: String,
    /// Request body.
    pub body: MagicAppConfigUpdateRequest,
}

/// Arguments for [`magic-site-app-configs-patch-app-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAppConfigsPatchAppConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `app_config_id`.
    pub app_config_id: String,
    /// Request body.
    pub body: MagicAppConfigUpdateRequest,
}

/// Arguments for [`magic-site-app-configs-delete-app-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteAppConfigsDeleteAppConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `app_config_id`.
    pub app_config_id: String,
}

/// Arguments for [`magic-site-lans-list-lans_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansListLansArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-lans-create-lan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansCreateLanArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicLansAddSingleRequest,
}

/// Arguments for [`magic-site-lans-lan-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansLanDetailsArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `lan_id`.
    pub lan_id: String,
}

/// Arguments for [`magic-site-lans-update-lan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansUpdateLanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `lan_id`.
    pub lan_id: String,
    /// Request body.
    pub body: MagicLanUpdateRequest,
}

/// Arguments for [`magic-site-lans-patch-lan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansPatchLanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `lan_id`.
    pub lan_id: String,
    /// Request body.
    pub body: MagicLanUpdateRequest,
}

/// Arguments for [`magic-site-lans-delete-lan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteLansDeleteLanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `lan_id`.
    pub lan_id: String,
}

/// Arguments for [`magic-site-netflow-config-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteNetflowConfigDetailsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-netflow-config-create-netflow-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteNetflowConfigCreateNetflowConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicNetflowConfigRequest,
}

/// Arguments for [`magic-site-netflow-config-update-netflow-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteNetflowConfigUpdateNetflowConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicNetflowConfigRequest,
}

/// Arguments for [`magic-site-netflow-config-patch-netflow-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteNetflowConfigPatchNetflowConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicNetflowConfigRequest,
}

/// Arguments for [`magic-site-netflow-config-delete-netflow-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteNetflowConfigDeleteNetflowConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-wans-list-wans_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansListWansArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
}

/// Arguments for [`magic-site-wans-create-wan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansCreateWanArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Request body.
    pub body: MagicWansAddSingleRequest,
}

/// Arguments for [`magic-site-wans-wan-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansWanDetailsArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `wan_id`.
    pub wan_id: String,
}

/// Arguments for [`magic-site-wans-update-wan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansUpdateWanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `wan_id`.
    pub wan_id: String,
    /// Request body.
    pub body: MagicWanUpdateRequest,
}

/// Arguments for [`magic-site-wans-patch-wan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansPatchWanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `wan_id`.
    pub wan_id: String,
    /// Request body.
    pub body: MagicWanUpdateRequest,
}

/// Arguments for [`magic-site-wans-delete-wan_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicSiteWansDeleteWanArgs {
    /// Path parameter: `site_id`.
    pub site_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `wan_id`.
    pub wan_id: String,
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/address_maps
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/addressing/address_maps
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/address_maps/{address_map_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/addressing/address_maps/{address_map_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/addressing/address_maps/{address_map_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/addressing/address_maps/{address_map_id}/ips/{ip_address}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/addressing/address_maps/{address_map_id}/ips/{ip_address}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/leases
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/addressing/loa_documents
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/loa_documents/{loa_document_id}/download
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/prefixes
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/addressing/prefixes
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/addressing/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/addressing/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/addressing/prefixes/{prefix_id}/delegations
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/addressing/prefixes/{prefix_id}/delegations
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/addressing/prefixes/{prefix_id}/delegations/{delegation_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/addressing/prefixes/{prefix_id}/validate
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = delete_allowlist_prefixes_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_allowlist_prefixes_for_account_request<F>(
    client: DynNetClient,
    args: &DeleteAllowlistPrefixesForAccountArgs,
    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/allowlist",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist/{prefix_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/allowlist/{prefix_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = delete_allowlist_prefix_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_allowlist_prefix_request<F>(
    client: DynNetClient,
    args: &DeleteAllowlistPrefixArgs,
    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/allowlist/{}",
        args.account_id,
        args.prefix_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = delete_prefixes_for_account_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_prefixes_for_account_request<F>(
    client: DynNetClient,
    args: &DeletePrefixesForAccountArgs,
    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/prefixes",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes/bulk
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes/{prefix_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/advanced_tcp_protection/configs/prefixes/{prefix_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = delete_prefix_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn delete_prefix_request<F>(
    client: DynNetClient,
    args: &DeletePrefixArgs,
    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/prefixes/{}",
        args.account_id,
        args.prefix_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_protection_status
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/advanced_tcp_protection/configs/tcp_protection_status
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/apps
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/apps
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/apps/{account_app_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/apps/{account_app_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/apps/{account_app_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/onramps
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/onramps
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/onramps/magic_wan_address_space
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/cloud/onramps/magic_wan_address_space
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/cloud/onramps/magic_wan_address_space
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/onramps/{onramp_id}
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/cloud/onramps/{onramp_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/cloud/onramps/{onramp_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/cloud/onramps/{onramp_id}
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/onramps/{onramp_id}/apply
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/onramps/{onramp_id}/export
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/onramps/{onramp_id}/plan
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/providers
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/providers
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/providers/discover
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/providers/{provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/cloud/providers/{provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/cloud/providers/{provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/cloud/providers/{provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/cloud/providers/{provider_id}/discover
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/cloud/providers/{provider_id}/initial_setup
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/connectors
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/connectors/{connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/connectors/{connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/connectors/{connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/events
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/events/latest
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/events/{event_t}.{event_n}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/snapshots
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/snapshots/latest
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/connectors/{connector_id}/telemetry/snapshots/{snapshot_t}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/routes
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/routes
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/routes
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/routes
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/routes/{route_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/routes/{route_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/routes/{route_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/acls
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites/{site_id}/acls
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/acls/{acl_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}/acls/{acl_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}/acls/{acl_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}/acls/{acl_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/app_configs
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites/{site_id}/app_configs
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}/app_configs/{app_config_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}/app_configs/{app_config_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}/app_configs/{app_config_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/lans
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites/{site_id}/lans
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/lans/{lan_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}/lans/{lan_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}/lans/{lan_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}/lans/{lan_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/netflow_config
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites/{site_id}/netflow_config
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}/netflow_config
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}/netflow_config
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}/netflow_config
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/wans
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/magic/sites/{site_id}/wans
// -----------------------------------------------------------------------------

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: MagicWanModifiedResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = magic_site_wans_patch_wan_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_site_wans_patch_wan_request<F>(
    client: DynNetClient,
    args: &MagicSiteWansPatchWanArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicWanModifiedResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/sites/{}/wans/{}",
        args.account_id,
        args.site_id,
        args.wan_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: MagicWanModifiedResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/magic/sites/{site_id}/wans/{wan_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = magic_site_wans_delete_wan_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_site_wans_delete_wan_request<F>(
    client: DynNetClient,
    args: &MagicSiteWansDeleteWanArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicWanDeletedResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/magic/sites/{}/wans/{}",
        args.account_id,
        args.site_id,
        args.wan_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: MagicWanDeletedResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}