foundation_deployment_cloudflare 0.1.1

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

#![cfg(feature = "cloudflare_load_balancers")]
#![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::LoadBalancingHealthDetails;
use super::shared::LoadBalancingIdResponse;
use super::shared::LoadBalancingMonitorReferencesResponse;
use super::shared::LoadBalancingMonitorResponseCollection;
use super::shared::LoadBalancingMonitorResponseSingle;
use super::shared::LoadBalancingPoolsReferencesResponse;
use super::shared::LoadBalancingPreviewResponse;
use super::shared::LoadBalancingPreviewResultResponse;
use super::shared::LoadBalancingSchemasIdResponse;
use super::shared::LoadBalancingSchemasResponseCollection;
use super::shared::LoadBalancingSchemasSingleResponse;
use super::shared::MagicVisibilityMnmMnmConfigSingleResponse;
use super::shared::LoadBalancingAddress;
use super::shared::LoadBalancingAllowInsecure;
use super::shared::LoadBalancingApiPaginatedResponseCollection;
use super::shared::LoadBalancingApiResponseCommon;
use super::shared::LoadBalancingApiResponseSingle;
use super::shared::LoadBalancingConsecutiveDown;
use super::shared::LoadBalancingConsecutiveUp;
use super::shared::LoadBalancingDescription;
use super::shared::LoadBalancingDisabledAt;
use super::shared::LoadBalancingEnabled;
use super::shared::LoadBalancingExpectedBody;
use super::shared::LoadBalancingExpectedCodes;
use super::shared::LoadBalancingFilterOptions;
use super::shared::LoadBalancingFollowRedirects;
use super::shared::LoadBalancingHeader;
use super::shared::LoadBalancingIdentifier;
use super::shared::LoadBalancingInterval;
use super::shared::LoadBalancingLatitude;
use super::shared::LoadBalancingLoadShedding;
use super::shared::LoadBalancingLongitude;
use super::shared::LoadBalancingMethod;
use super::shared::LoadBalancingMinimumOrigins;
use super::shared::LoadBalancingMonitor;
use super::shared::LoadBalancingMonitorEditable;
use super::shared::LoadBalancingMonitorGroupId;
use super::shared::LoadBalancingMonitorId;
use super::shared::LoadBalancingName;
use super::shared::LoadBalancingNotificationEmail;
use super::shared::LoadBalancingNotificationFilter;
use super::shared::LoadBalancingOrigin;
use super::shared::LoadBalancingOriginHealth;
use super::shared::LoadBalancingOriginPort;
use super::shared::LoadBalancingOriginSteering;
use super::shared::LoadBalancingPath;
use super::shared::LoadBalancingPool;
use super::shared::LoadBalancingPort;
use super::shared::LoadBalancingPreviewResult;
use super::shared::LoadBalancingProbeZone;
use super::shared::LoadBalancingResultInfo;
use super::shared::LoadBalancingRetries;
use super::shared::LoadBalancingSchemasDescription;
use super::shared::LoadBalancingSchemasDisabledAt;
use super::shared::LoadBalancingSchemasEnabled;
use super::shared::LoadBalancingSchemasHeader;
use super::shared::LoadBalancingSchemasIdentifier;
use super::shared::LoadBalancingSchemasName;
use super::shared::LoadBalancingTimeout;
use super::shared::LoadBalancingTimestamp;
use super::shared::LoadBalancingType;
use super::shared::LoadBalancingVirtualNetworkId;
use super::shared::LoadBalancingWeight;
use super::shared::MagicVisibilityMnmApiResponseCommon;
use super::shared::MagicVisibilityMnmApiResponseSingle;
use super::shared::MagicVisibilityMnmMnmConfig;
use super::shared::MagicVisibilityMnmMnmConfigDefaultSampling;
use super::shared::MagicVisibilityMnmMnmConfigName;
use super::shared::MagicVisibilityMnmMnmConfigRouterIp;
use super::shared::MagicVisibilityMnmMnmConfigWarpDevice;

use super::shared::ApiResponse;

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

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

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

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

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

/// `AccountLoadBalancerPoolsCreatePoolRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccountLoadBalancerPoolsCreatePoolRequest {
    /// description property.
    pub description: Option<LoadBalancingSchemasDescription>,
    /// enabled property.
    pub enabled: Option<LoadBalancingEnabled>,
    /// latitude property.
    pub latitude: Option<LoadBalancingLatitude>,
    /// load_shedding property.
    pub load_shedding: Option<LoadBalancingLoadShedding>,
    /// longitude property.
    pub longitude: Option<LoadBalancingLongitude>,
    /// minimum_origins property.
    pub minimum_origins: Option<LoadBalancingMinimumOrigins>,
    /// monitor property.
    pub monitor: Option<LoadBalancingMonitorId>,
    /// monitor_group property.
    pub monitor_group: Option<LoadBalancingMonitorGroupId>,
    /// name property.
    pub name: LoadBalancingName,
    /// notification_email property.
    pub notification_email: Option<LoadBalancingNotificationEmail>,
    /// notification_filter property.
    pub notification_filter: Option<LoadBalancingNotificationFilter>,
    /// origin_steering property.
    pub origin_steering: Option<LoadBalancingOriginSteering>,
    /// origins property.
    pub origins: Vec<LoadBalancingOrigin>,
}

/// `AccountLoadBalancerPoolsPatchPoolRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPatchPoolRequest {
    /// check_regions property.
    pub check_regions: Option<Vec<String>>,
    /// description property.
    pub description: Option<LoadBalancingSchemasDescription>,
    /// disabled_at property.
    pub disabled_at: Option<LoadBalancingSchemasDisabledAt>,
    /// enabled property.
    pub enabled: Option<LoadBalancingEnabled>,
    /// latitude property.
    pub latitude: Option<LoadBalancingLatitude>,
    /// load_shedding property.
    pub load_shedding: Option<LoadBalancingLoadShedding>,
    /// longitude property.
    pub longitude: Option<LoadBalancingLongitude>,
    /// minimum_origins property.
    pub minimum_origins: Option<LoadBalancingMinimumOrigins>,
    /// monitor property.
    pub monitor: Option<LoadBalancingMonitorId>,
    /// monitor_group property.
    pub monitor_group: Option<LoadBalancingMonitorGroupId>,
    /// name property.
    pub name: Option<LoadBalancingName>,
    /// notification_email property.
    pub notification_email: Option<LoadBalancingNotificationEmail>,
    /// notification_filter property.
    pub notification_filter: Option<LoadBalancingNotificationFilter>,
    /// origin_steering property.
    pub origin_steering: Option<LoadBalancingOriginSteering>,
    /// origins property.
    pub origins: Option<Vec<LoadBalancingOrigin>>,
}

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

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

/// `AccountLoadBalancerPoolsUpdatePoolRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccountLoadBalancerPoolsUpdatePoolRequest {
    /// check_regions property.
    pub check_regions: Option<Vec<String>>,
    /// description property.
    pub description: Option<LoadBalancingSchemasDescription>,
    /// disabled_at property.
    pub disabled_at: Option<LoadBalancingSchemasDisabledAt>,
    /// enabled property.
    pub enabled: Option<LoadBalancingEnabled>,
    /// latitude property.
    pub latitude: Option<LoadBalancingLatitude>,
    /// load_shedding property.
    pub load_shedding: Option<LoadBalancingLoadShedding>,
    /// longitude property.
    pub longitude: Option<LoadBalancingLongitude>,
    /// minimum_origins property.
    pub minimum_origins: Option<LoadBalancingMinimumOrigins>,
    /// monitor property.
    pub monitor: Option<LoadBalancingMonitorId>,
    /// monitor_group property.
    pub monitor_group: Option<LoadBalancingMonitorGroupId>,
    /// name property.
    pub name: LoadBalancingName,
    /// notification_email property.
    pub notification_email: Option<LoadBalancingNotificationEmail>,
    /// notification_filter property.
    pub notification_filter: Option<LoadBalancingNotificationFilter>,
    /// origin_steering property.
    pub origin_steering: Option<LoadBalancingOriginSteering>,
    /// origins property.
    pub origins: Vec<LoadBalancingOrigin>,
}

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

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

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

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

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

/// `LoadBalancingMonitorGroup` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancingMonitorGroup {
    /// created_at property.
    pub created_at: Option<String>,
    /// description property.
    pub description: String,
    /// id property.
    pub id: LoadBalancingMonitorGroupId,
    /// members property.
    pub members: Vec<LoadBalancingMonitorGroupMember>,
    /// updated_at property.
    pub updated_at: Option<String>,
}

/// `LoadBalancingMonitorGroupMember` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancingMonitorGroupMember {
    /// created_at property.
    pub created_at: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// monitor_id property.
    pub monitor_id: LoadBalancingMonitorId,
    /// monitoring_only property.
    pub monitoring_only: bool,
    /// must_be_healthy property.
    pub must_be_healthy: bool,
    /// updated_at property.
    pub updated_at: Option<String>,
}

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

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

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

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

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

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

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

/// `LoadBalancingResourceReference` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancingResourceReference {
    /// reference_type property.
    pub reference_type: Option<String>,
    /// references property.
    pub references: Option<Vec<serde_json::Value>>,
    /// resource_id property.
    pub resource_id: Option<String>,
    /// resource_name property.
    pub resource_name: Option<String>,
    /// resource_type property.
    pub resource_type: Option<String>,
}

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

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

/// `MagicNetworkMonitoringConfigurationCreateAccountConfigurationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationCreateAccountConfigurationRequest {
    /// default_sampling property.
    pub default_sampling: MagicVisibilityMnmMnmConfigDefaultSampling,
    /// name property.
    pub name: MagicVisibilityMnmMnmConfigName,
    /// router_ips property.
    pub router_ips: Option<Vec<MagicVisibilityMnmMnmConfigRouterIp>>,
    /// warp_devices property.
    pub warp_devices: Option<Vec<MagicVisibilityMnmMnmConfigWarpDevice>>,
}

/// `MagicNetworkMonitoringConfigurationUpdateAccountConfigurationFieldsRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationUpdateAccountConfigurationFieldsRequest {
    /// default_sampling property.
    pub default_sampling: Option<MagicVisibilityMnmMnmConfigDefaultSampling>,
    /// name property.
    pub name: Option<MagicVisibilityMnmMnmConfigName>,
    /// router_ips property.
    pub router_ips: Option<Vec<MagicVisibilityMnmMnmConfigRouterIp>>,
    /// warp_devices property.
    pub warp_devices: Option<Vec<MagicVisibilityMnmMnmConfigWarpDevice>>,
}

/// `MagicNetworkMonitoringConfigurationUpdateAnEntireAccountConfigurationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationUpdateAnEntireAccountConfigurationRequest {
    /// default_sampling property.
    pub default_sampling: MagicVisibilityMnmMnmConfigDefaultSampling,
    /// name property.
    pub name: MagicVisibilityMnmMnmConfigName,
    /// router_ips property.
    pub router_ips: Option<Vec<MagicVisibilityMnmMnmConfigRouterIp>>,
    /// warp_devices property.
    pub warp_devices: Option<Vec<MagicVisibilityMnmMnmConfigWarpDevice>>,
}

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

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

/// `MagicTransitEndpointHealthCheck` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicTransitEndpointHealthCheck {
    /// check_type property.
    pub check_type: MagicTransitCheckType,
    /// endpoint property.
    pub endpoint: String,
    /// name property.
    pub name: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

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

/// Arguments for [`diagnostics-endpoint-healthcheck-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DiagnosticsEndpointHealthcheckCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicTransitEndpointHealthCheck,
}

/// Arguments for [`diagnostics-endpoint-healthcheck-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DiagnosticsEndpointHealthcheckGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
}

/// Arguments for [`diagnostics-endpoint-healthcheck-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DiagnosticsEndpointHealthcheckUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
    /// Request body.
    pub body: MagicTransitEndpointHealthCheck,
}

/// Arguments for [`diagnostics-endpoint-healthcheck-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DiagnosticsEndpointHealthcheckDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
}

/// Arguments for [`account-load-balancer-monitor-groups-list-monitor-groups_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsListMonitorGroupsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitor-groups-create-monitor-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsCreateMonitorGroupArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: LoadBalancingMonitorGroup,
}

/// Arguments for [`account-load-balancer-monitor-groups-monitor-group-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsMonitorGroupDetailsArgs {
    /// Path parameter: `monitor_group_id`.
    pub monitor_group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitor-groups-update-monitor-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsUpdateMonitorGroupArgs {
    /// Path parameter: `monitor_group_id`.
    pub monitor_group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: LoadBalancingMonitorGroup,
}

/// Arguments for [`account-load-balancer-monitor-groups-patch-monitor-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsPatchMonitorGroupArgs {
    /// Path parameter: `monitor_group_id`.
    pub monitor_group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: LoadBalancingMonitorGroup,
}

/// Arguments for [`account-load-balancer-monitor-groups-delete-monitor-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsDeleteMonitorGroupArgs {
    /// Path parameter: `monitor_group_id`.
    pub monitor_group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitor-groups-list-monitor-group-references_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorGroupsListMonitorGroupReferencesArgs {
    /// Path parameter: `monitor_group_id`.
    pub monitor_group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitors-list-monitors_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsListMonitorsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitors-create-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsCreateMonitorArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerMonitorsCreateMonitorRequest,
}

/// Arguments for [`account-load-balancer-monitors-monitor-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsMonitorDetailsArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitors-update-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsUpdateMonitorArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerMonitorsUpdateMonitorRequest,
}

/// Arguments for [`account-load-balancer-monitors-patch-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsPatchMonitorArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerMonitorsPatchMonitorRequest,
}

/// Arguments for [`account-load-balancer-monitors-delete-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsDeleteMonitorArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitors-preview-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsPreviewMonitorArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerMonitorsPreviewMonitorRequest,
}

/// Arguments for [`account-load-balancer-monitors-list-monitor-references_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsListMonitorReferencesArgs {
    /// Path parameter: `monitor_id`.
    pub monitor_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-pools-list-pools_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsListPoolsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `monitor`.
    pub monitor: Option<String>,
}

/// Arguments for [`account-load-balancer-pools-create-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsCreatePoolArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerPoolsCreatePoolRequest,
}

/// Arguments for [`account-load-balancer-pools-patch-pools_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPatchPoolsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerPoolsPatchPoolsRequest,
}

/// Arguments for [`account-load-balancer-pools-pool-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPoolDetailsArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-pools-update-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsUpdatePoolArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerPoolsUpdatePoolRequest,
}

/// Arguments for [`account-load-balancer-pools-patch-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPatchPoolArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerPoolsPatchPoolRequest,
}

/// Arguments for [`account-load-balancer-pools-delete-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsDeletePoolArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-pools-pool-health-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPoolHealthDetailsArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-pools-preview-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsPreviewPoolArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountLoadBalancerPoolsPreviewPoolRequest,
}

/// Arguments for [`account-load-balancer-pools-list-pool-references_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerPoolsListPoolReferencesArgs {
    /// Path parameter: `pool_id`.
    pub pool_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-monitors-preview-result_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerMonitorsPreviewResultArgs {
    /// Path parameter: `preview_id`.
    pub preview_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`load-balancer-regions-list-regions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerRegionsListRegionsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `subdivision_code`.
    pub subdivision_code: Option<String>,
    /// Query parameter: `subdivision_code_a2`.
    pub subdivision_code_a2: Option<String>,
    /// Query parameter: `country_code_a2`.
    pub country_code_a2: Option<String>,
}

/// Arguments for [`load-balancer-regions-get-region_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerRegionsGetRegionArgs {
    /// Path parameter: `region_id`.
    pub region_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-load-balancer-search-search-resources_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountLoadBalancerSearchSearchResourcesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `query`.
    pub query: Option<String>,
    /// Query parameter: `references`.
    pub references: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

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

/// Arguments for [`magic-network-monitoring-configuration-create-account-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationCreateAccountConfigurationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringConfigurationCreateAccountConfigurationRequest,
}

/// Arguments for [`magic-network-monitoring-configuration-update-an-entire-account-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationUpdateAnEntireAccountConfigurationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringConfigurationUpdateAnEntireAccountConfigurationRequest,
}

/// Arguments for [`magic-network-monitoring-configuration-update-account-configuration-fields_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringConfigurationUpdateAccountConfigurationFieldsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicNetworkMonitoringConfigurationUpdateAccountConfigurationFieldsRequest,
}

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

/// Arguments for [`magic-network-monitoring-vpc-flows-generate-authentication-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicNetworkMonitoringVpcFlowsGenerateAuthenticationTokenArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/diagnostics/endpoint-healthchecks
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    builder = builder.query("subdivision_code", args.subdivision_code.as_deref());
    builder = builder.query("subdivision_code_a2", args.subdivision_code_a2.as_deref());
    builder = builder.query("country_code_a2", args.country_code_a2.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: LoadBalancingRegionComponentsSchemasResponseCollection = 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}/load_balancers/regions/{region_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

/// POST /accounts/{account_id}/mnm/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_network_monitoring_configuration_create_account_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_configuration_create_account_configuration_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringConfigurationCreateAccountConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmConfigSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/config",
        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: MagicVisibilityMnmMnmConfigSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

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

/// PUT /accounts/{account_id}/mnm/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_network_monitoring_configuration_update_an_entire_account_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_configuration_update_an_entire_account_configuration_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringConfigurationUpdateAnEntireAccountConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmConfigSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/config",
        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: MagicVisibilityMnmMnmConfigSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/mnm/config
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/mnm/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_network_monitoring_configuration_update_account_configuration_fields_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_configuration_update_account_configuration_fields_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringConfigurationUpdateAccountConfigurationFieldsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmConfigSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/config",
        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: MagicVisibilityMnmMnmConfigSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/mnm/config
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/mnm/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_network_monitoring_configuration_delete_account_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_network_monitoring_configuration_delete_account_configuration_request<F>(
    client: DynNetClient,
    args: &MagicNetworkMonitoringConfigurationDeleteAccountConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityMnmMnmConfigSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/mnm/config",
        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: MagicVisibilityMnmMnmConfigSingleResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/mnm/vpc-flows/token
// -----------------------------------------------------------------------------

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