foundation_deployment_cloudflare 0.1.1

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

#![cfg(feature = "cloudflare_access")]
#![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::AaaAuditLogsResponseCollection;
use super::shared::AccessAppSettingsRequest;
use super::shared::AccessComponentsSchemasIdResponse;
use super::shared::AccessEmptyResponse;
use super::shared::AccessIdResponse;
use super::shared::AccessResponseCollectionHostnames;
use super::shared::AccessSchemasEmptyResponse;
use super::shared::AddressingApiResponseCollection;
use super::shared::BillSubsApiSubscriptionV2;
use super::shared::IamApiResponseSingleId;
use super::shared::IamCollectionTokensResponse;
use super::shared::IamCreatePayload;
use super::shared::IamPermissionsGroupResponseCollection;
use super::shared::IamResponseSingleValue;
use super::shared::IamSingleTokenCreateResponse;
use super::shared::IamSingleTokenResponse;
use super::shared::IamTokenBody;
use super::shared::IamTokenVerifyResponseSingleSegment;
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::OrganizationsApiProfile;
use super::shared::ResourceSharingShareResponseCollection;
use super::shared::AaaResultInfo;
use super::shared::AccessAllowIframe;
use super::shared::AccessApiResponseCollection;
use super::shared::AccessApiResponseCommon;
use super::shared::AccessApiResponseSingle;
use super::shared::AccessSettings;
use super::shared::AccessSkipInterstitial;
use super::shared::AccessUuid;
use super::shared::AddressingApiResponseCommon;
use super::shared::BillSubsApiComponentValue;
use super::shared::BillSubsApiCurrency;
use super::shared::BillSubsApiCurrentPeriodEnd;
use super::shared::BillSubsApiCurrentPeriodStart;
use super::shared::BillSubsApiFrequency;
use super::shared::BillSubsApiIdentifier;
use super::shared::BillSubsApiName;
use super::shared::BillSubsApiPrice;
use super::shared::BillSubsApiRatePlan;
use super::shared::BillSubsApiSchemasIdentifier;
use super::shared::BillSubsApiState;
use super::shared::BillSubsApiZone;
use super::shared::IamApiResponseCollection;
use super::shared::IamApiResponseCommon;
use super::shared::IamApiResponseSingle;
use super::shared::IamCommonComponentsSchemasIdentifier;
use super::shared::IamCondition;
use super::shared::IamEffect;
use super::shared::IamExpiresOn;
use super::shared::IamIssuedOn;
use super::shared::IamLastUsedOn;
use super::shared::IamModifiedOn;
use super::shared::IamName;
use super::shared::IamNotBefore;
use super::shared::IamPermissionGroup;
use super::shared::IamPolicyIdentifier;
use super::shared::IamPolicyWithPermissionGroupsAndResources;
use super::shared::IamRequestIp;
use super::shared::IamResources;
use super::shared::IamResourcesTypeObjectNested;
use super::shared::IamResourcesTypeObjectString;
use super::shared::IamResultInfo;
use super::shared::IamTokenBase;
use super::shared::IamTokenIdentifier;
use super::shared::IamTokenStatus;
use super::shared::IamTokenWithValue;
use super::shared::IamValue;
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::ResourceSharingAccountId;
use super::shared::ResourceSharingAccountName;
use super::shared::ResourceSharingApiResponseCollection;
use super::shared::ResourceSharingApiResponseCommon;
use super::shared::ResourceSharingCreated;
use super::shared::ResourceSharingModified;
use super::shared::ResourceSharingOrganizationId;
use super::shared::ResourceSharingResourceId;
use super::shared::ResourceSharingResourceMeta;
use super::shared::ResourceSharingResourceResourceId;
use super::shared::ResourceSharingResourceStatus;
use super::shared::ResourceSharingResourceType;
use super::shared::ResourceSharingResourceVersion;
use super::shared::ResourceSharingResultInfo;
use super::shared::ResourceSharingShareId;
use super::shared::ResourceSharingShareKind;
use super::shared::ResourceSharingShareName;
use super::shared::ResourceSharingShareObject;
use super::shared::ResourceSharingShareResourceObject;
use super::shared::ResourceSharingShareStatus;
use super::shared::ResourceSharingShareTargetType;
use super::shared::ResourceSharingV4Error;

use super::shared::ApiResponse;

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

/// `AaaAuditLogAction` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaAuditLogAction {
    /// description property.
    pub description: Option<String>,
    /// result property.
    pub result: Option<String>,
    /// time property.
    pub time: Option<String>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<String>,
}

/// `AaaAuditLogRaw` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaAuditLogRaw {
    /// cf_ray_id property.
    pub cf_ray_id: Option<String>,
    /// method property.
    pub method: Option<String>,
    /// status_code property.
    pub status_code: Option<i64>,
    /// uri property.
    pub uri: Option<String>,
    /// user_agent property.
    pub user_agent: Option<String>,
}

/// `AaaAuditLogsV2Org` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AaaAuditLogsV2Org {
    /// action property.
    pub action: Option<AaaAuditLogAction>,
    /// actor property.
    pub actor: Option<serde_json::Value>,
    /// id property.
    pub id: Option<AaaSchemasIdentifier>,
    /// organization property.
    pub organization: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// raw property.
    #[serde(rename = "raw")]
    pub r#raw: Option<AaaAuditLogRaw>,
    /// resource property.
    pub resource: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

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

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

/// `AbuseReportsAbuseReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsAbuseReport {
    /// cdate property.
    pub cdate: String,
    /// domain property.
    pub domain: String,
    /// id property.
    pub id: String,
    /// justification property.
    pub justification: Option<String>,
    /// mitigation_summary property.
    pub mitigation_summary: AbuseReportsMitigationSummary,
    /// original_work property.
    pub original_work: Option<String>,
    /// status property.
    pub status: AbuseReportsReportStatus,
    /// submitter property.
    pub submitter: Option<AbuseReportsSubmitterDetails>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: AbuseReportsReportType,
    /// urls property.
    pub urls: Option<Vec<String>>,
}

/// `AbuseReportsBaseReportFields` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsBaseReportFields {
    /// act property.
    pub act: AbuseReportsSubmissionReportType,
    /// comments property.
    pub comments: Option<String>,
    /// company property.
    pub company: Option<String>,
    /// email property.
    pub email: String,
    /// email2 property.
    pub email2: String,
    /// name property.
    pub name: String,
    /// reported_country property.
    pub reported_country: Option<String>,
    /// reported_user_agent property.
    pub reported_user_agent: Option<String>,
    /// tele property.
    pub tele: Option<String>,
    /// title property.
    pub title: Option<String>,
    /// urls property.
    pub urls: String,
}

/// `AbuseReportsCSAMReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsCSAMReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `country` property.
    pub country: Option<String>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `justification` property.
    pub justification: String,
    /// `ncmec_notification` property.
    pub ncmec_notification: String,
    /// `owner_notification` property.
    pub owner_notification: String,
}

/// `AbuseReportsDMCAReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsDMCAReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `address1` property.
    pub address1: String,
    /// `agent_name` property.
    pub agent_name: String,
    /// `agree` property.
    pub agree: i64,
    /// `city` property.
    pub city: String,
    /// `country` property.
    pub country: String,
    /// `host_notification` property.
    pub host_notification: String,
    /// `original_work` property.
    pub original_work: String,
    /// `owner_notification` property.
    pub owner_notification: String,
    /// `signature` property.
    pub signature: String,
    /// `state` property.
    pub state: String,
}

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

/// `AbuseReportsGeneralReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsGeneralReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `destination_ips` property.
    pub destination_ips: Option<String>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `justification` property.
    pub justification: String,
    /// `owner_notification` property.
    pub owner_notification: String,
    /// `ports_protocols` property.
    pub ports_protocols: Option<String>,
    /// `source_ips` property.
    pub source_ips: Option<String>,
}

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

/// `AbuseReportsMitigationSummary` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsMitigationSummary {
    /// accepted_url_count property.
    pub accepted_url_count: i64,
    /// active_count property.
    pub active_count: i64,
    /// external_host_notified property.
    pub external_host_notified: bool,
    /// in_review_count property.
    pub in_review_count: i64,
    /// pending_count property.
    pub pending_count: i64,
}

/// `AbuseReportsNCSEIReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsNCSEIReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `country` property.
    pub country: Option<String>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `ncsei_subject_representation` property.
    pub ncsei_subject_representation: bool,
    /// `owner_notification` property.
    pub owner_notification: String,
}

/// `AbuseReportsPhishingReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsPhishingReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `justification` property.
    pub justification: String,
    /// `original_work` property.
    pub original_work: Option<String>,
    /// `owner_notification` property.
    pub owner_notification: String,
}

/// `AbuseReportsRegistrarWhoIsFields` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsRegistrarWhoIsFields {
    /// reg_who_authorization_statement property.
    pub reg_who_authorization_statement: Option<String>,
    /// reg_who_good_faith_affirmation property.
    pub reg_who_good_faith_affirmation: Option<bool>,
    /// reg_who_lawful_processing_agreement property.
    pub reg_who_lawful_processing_agreement: Option<bool>,
    /// reg_who_legal_basis property.
    pub reg_who_legal_basis: Option<String>,
    /// reg_who_request_type property.
    pub reg_who_request_type: Option<String>,
    /// reg_who_requested_data_elements property.
    pub reg_who_requested_data_elements: Option<Vec<String>>,
    /// reg_who_requestor_type property.
    pub reg_who_requestor_type: Option<String>,
}

/// `AbuseReportsRegistrarWhoisReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsRegistrarWhoisReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `owner_notification` property.
    pub owner_notification: String,
    /// `reg_who_request` property.
    pub reg_who_request: Option<AbuseReportsRegistrarWhoIsFields>,
}

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

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

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

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

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

/// `AbuseReportsSubmitterDetails` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsSubmitterDetails {
    /// company property.
    pub company: Option<String>,
    /// email property.
    pub email: Option<String>,
    /// name property.
    pub name: Option<String>,
    /// telephone property.
    pub telephone: Option<String>,
}

/// `AbuseReportsThreatReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsThreatReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `justification` property.
    pub justification: String,
    /// `owner_notification` property.
    pub owner_notification: String,
}

/// `AbuseReportsTrademarkReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AbuseReportsTrademarkReport {
    /// `act` property.
    pub act: Option<serde_json::Value>,
    /// `host_notification` property.
    pub host_notification: String,
    /// `justification` property.
    pub justification: String,
    /// `owner_notification` property.
    pub owner_notification: String,
    /// `trademark_number` property.
    pub trademark_number: String,
    /// `trademark_office` property.
    pub trademark_office: String,
    /// `trademark_symbol` property.
    pub trademark_symbol: String,
}

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

/// `AccessAccessRequests` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessAccessRequests {
    /// action property.
    pub action: Option<AccessAction>,
    /// allowed property.
    pub allowed: Option<AccessAllowed>,
    /// app_domain property.
    pub app_domain: Option<AccessAppDomain>,
    /// app_uid property.
    pub app_uid: Option<AccessAppUid>,
    /// connection property.
    pub connection: Option<AccessConnection>,
    /// created_at property.
    pub created_at: Option<AccessTimestamp>,
    /// ip_address property.
    pub ip_address: Option<AccessIp>,
    /// ray_id property.
    pub ray_id: Option<AccessRayId>,
    /// user_email property.
    pub user_email: Option<AccessComponentsSchemasEmail>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessAppLauncherProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessAppLauncherProps {
    /// `app_launcher_logo_url` property.
    pub app_launcher_logo_url: Option<AccessAppLauncherLogoUrl>,
    /// `bg_color` property.
    pub bg_color: Option<AccessBgColor>,
    /// `domain` property.
    pub domain: Option<serde_json::Value>,
    /// `footer_links` property.
    pub footer_links: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
    /// `header_bg_color` property.
    pub header_bg_color: Option<AccessHeaderBgColor>,
    /// `landing_page_design` property.
    pub landing_page_design: Option<AccessLandingPageDesign>,
    /// `name` property.
    pub name: Option<serde_json::Value>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
    /// `skip_app_launcher_login_page` property.
    pub skip_app_launcher_login_page: Option<AccessSkipAppLauncherLoginPage>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessAppSettingsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessAppSettingsResponse {
    /// allow_iframe property.
    pub allow_iframe: Option<AccessAllowIframe>,
    /// skip_interstitial property.
    pub skip_interstitial: Option<AccessSkipInterstitial>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessAzureGroupRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessAzureGroupRule {
    /// azureAD property.
    #[serde(rename = "azureAD")]
    pub azure_ad: std::collections::HashMap<String, serde_json::Value>,
}

/// `AccessBasePolicyReq` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessBasePolicyReq {
    /// decision property.
    pub decision: AccessDecision,
    /// exclude property.
    pub exclude: Option<Vec<AccessRule>>,
    /// include property.
    pub include: Vec<AccessRule>,
    /// name property.
    pub name: AccessPolicyComponentsSchemasName,
    /// require property.
    pub require: Option<Vec<AccessRule>>,
}

/// `AccessBasePolicyResp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessBasePolicyResp {
    /// created_at property.
    pub created_at: Option<AccessTimestamp>,
    /// decision property.
    pub decision: Option<AccessDecision>,
    /// exclude property.
    pub exclude: Option<Vec<AccessRule>>,
    /// id property.
    pub id: Option<AccessSchemasUuid>,
    /// include property.
    pub include: Option<Vec<AccessRule>>,
    /// name property.
    pub name: Option<AccessPolicyComponentsSchemasName>,
    /// require property.
    pub require: Option<Vec<AccessRule>>,
    /// updated_at property.
    pub updated_at: Option<AccessTimestamp>,
}

/// `AccessBasicAppResponseProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessBasicAppResponseProps {
    /// aud property.
    pub aud: Option<AccessSchemasAud>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// id property.
    pub id: Option<AccessUuid>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

/// `AccessBisoProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessBisoProps {
    /// `domain` property.
    pub domain: Option<serde_json::Value>,
    /// `name` property.
    pub name: Option<serde_json::Value>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

/// `AccessBookmarkProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessBookmarkProps {
    /// app_launcher_visible property.
    pub app_launcher_visible: Option<AccessAppLauncherVisible>,
    /// domain property.
    pub domain: Option<String>,
    /// logo_url property.
    pub logo_url: Option<AccessLogoUrl>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// tags property.
    pub tags: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

/// `AccessCa` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessCa {
    /// aud property.
    pub aud: Option<AccessAud>,
    /// id property.
    pub id: Option<AccessSchemasId>,
    /// public_key property.
    pub public_key: Option<AccessPublicKey>,
}

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

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

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

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

/// `AccessCertificates` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessCertificates {
    /// associated_hostnames property.
    pub associated_hostnames: Option<Vec<String>>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// expires_on property.
    pub expires_on: Option<AccessTimestamp>,
    /// fingerprint property.
    pub fingerprint: Option<AccessFingerprint>,
    /// id property.
    pub id: Option<String>,
    /// name property.
    pub name: Option<AccessCertificatesComponentsSchemasName>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessConnectionRulesRdp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessConnectionRulesRdp {
    /// allowed_clipboard_local_to_remote_formats property.
    pub allowed_clipboard_local_to_remote_formats: Option<Vec<AccessRdpClipboardFormat>>,
    /// allowed_clipboard_remote_to_local_formats property.
    pub allowed_clipboard_remote_to_local_formats: Option<Vec<AccessRdpClipboardFormat>>,
}

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

/// `AccessCorsHeaders` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessCorsHeaders {
    /// allow_all_headers property.
    pub allow_all_headers: Option<AccessAllowAllHeaders>,
    /// allow_all_methods property.
    pub allow_all_methods: Option<AccessAllowAllMethods>,
    /// allow_all_origins property.
    pub allow_all_origins: Option<AccessAllowAllOrigins>,
    /// allow_credentials property.
    pub allow_credentials: Option<AccessAllowCredentials>,
    /// allowed_headers property.
    pub allowed_headers: Option<Vec<String>>,
    /// allowed_methods property.
    pub allowed_methods: Option<Vec<String>>,
    /// allowed_origins property.
    pub allowed_origins: Option<Vec<String>>,
    /// max_age property.
    pub max_age: Option<AccessMaxAge>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessFeatureAppProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessFeatureAppProps {
    /// allowed_idps property.
    pub allowed_idps: Option<Vec<String>>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessSchemasAutoRedirectToIdentity>,
    /// custom_deny_url property.
    pub custom_deny_url: Option<AccessCustomDenyUrl>,
    /// custom_non_identity_deny_url property.
    pub custom_non_identity_deny_url: Option<AccessCustomNonIdentityDenyUrl>,
    /// custom_pages property.
    pub custom_pages: Option<Vec<String>>,
    /// domain property.
    pub domain: Option<AccessDomain>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// session_duration property.
    pub session_duration: Option<AccessSchemasSessionDuration>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: AccessType,
}

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

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

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

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

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

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

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

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

/// `AccessGithubOrganizationRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessGithubOrganizationRule {
    /// github-organization property.
    #[serde(rename = "github-organization")]
    pub github_organization: std::collections::HashMap<String, serde_json::Value>,
}

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

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

/// `AccessGroups` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessGroups {
    /// displayName property.
    #[serde(rename = "displayName")]
    pub display_name: Option<String>,
    /// externalId property.
    #[serde(rename = "externalId")]
    pub external_id: Option<AccessExternalId>,
    /// id property.
    pub id: Option<AccessId>,
    /// meta property.
    pub meta: Option<AccessMeta>,
    /// schemas property.
    pub schemas: Option<Vec<String>>,
}

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

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

/// `AccessGroupsCreateAnAccessGroupRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessGroupsCreateAnAccessGroupRequest {
    /// exclude property.
    pub exclude: Option<Vec<AccessRule>>,
    /// include property.
    pub include: Vec<AccessRule>,
    /// is_default property.
    pub is_default: Option<AccessIsDefault>,
    /// name property.
    pub name: AccessGroupsComponentsSchemasName,
    /// require property.
    pub require: Option<Vec<AccessRule>>,
}

/// `AccessGroupsUpdateAnAccessGroupRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessGroupsUpdateAnAccessGroupRequest {
    /// exclude property.
    pub exclude: Option<Vec<AccessRule>>,
    /// include property.
    pub include: Vec<AccessRule>,
    /// is_default property.
    pub is_default: Option<AccessIsDefault>,
    /// name property.
    pub name: AccessGroupsComponentsSchemasName,
    /// require property.
    pub require: Option<Vec<AccessRule>>,
}

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

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

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

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

/// `AccessIdentity` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessIdentity {
    /// account_id property.
    pub account_id: Option<String>,
    /// auth_status property.
    pub auth_status: Option<String>,
    /// common_name property.
    pub common_name: Option<String>,
    /// devicePosture property.
    #[serde(rename = "devicePosture")]
    pub device_posture: Option<serde_json::Value>,
    /// device_id property.
    pub device_id: Option<String>,
    /// device_sessions property.
    pub device_sessions: Option<AccessStringKeyMapDeviceSession>,
    /// email property.
    pub email: Option<String>,
    /// geo property.
    pub geo: Option<AccessGeo>,
    /// iat property.
    pub iat: Option<f64>,
    /// idp property.
    pub idp: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// ip property.
    pub ip: Option<String>,
    /// is_gateway property.
    pub is_gateway: Option<bool>,
    /// is_warp property.
    pub is_warp: Option<bool>,
    /// mtls_auth property.
    pub mtls_auth: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// service_token_id property.
    pub service_token_id: Option<String>,
    /// service_token_status property.
    pub service_token_status: Option<bool>,
    /// user_uuid property.
    pub user_uuid: Option<String>,
    /// version property.
    pub version: Option<f64>,
}

/// `AccessIdentityProvider` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessIdentityProvider {
    /// config property.
    pub config: serde_json::Value,
    /// id property.
    pub id: Option<AccessUuid>,
    /// name property.
    pub name: AccessComponentsSchemasName,
    /// scim_config property.
    pub scim_config: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: String,
}

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

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

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

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

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

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

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

/// `AccessInfraProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessInfraProps {
    /// `name` property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

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

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

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

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

/// `AccessKeyConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessKeyConfig {
    /// days_until_next_rotation property.
    pub days_until_next_rotation: Option<AccessDaysUntilNextRotation>,
    /// key_rotation_interval_days property.
    pub key_rotation_interval_days: Option<AccessKeyRotationIntervalDays>,
    /// last_key_rotation_at property.
    pub last_key_rotation_at: Option<AccessLastKeyRotationAt>,
}

/// `AccessKeyConfigurationUpdateTheAccessKeyConfigurationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessKeyConfigurationUpdateTheAccessKeyConfigurationRequest {
    /// key_rotation_interval_days property.
    pub key_rotation_interval_days: AccessKeyRotationIntervalDays,
}

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

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

/// `AccessLandingPageDesign` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessLandingPageDesign {
    /// button_color property.
    pub button_color: Option<AccessButtonColor>,
    /// button_text_color property.
    pub button_text_color: Option<AccessButtonTextColor>,
    /// image_url property.
    pub image_url: Option<AccessImageUrl>,
    /// message property.
    pub message: Option<AccessMessage>,
    /// title property.
    pub title: Option<AccessTitle>,
}

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

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

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

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

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

/// `AccessLoginDesign` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessLoginDesign {
    /// background_color property.
    pub background_color: Option<String>,
    /// footer_text property.
    pub footer_text: Option<String>,
    /// header_text property.
    pub header_text: Option<String>,
    /// logo_path property.
    pub logo_path: Option<String>,
    /// text_color property.
    pub text_color: Option<String>,
}

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

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

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

/// `AccessMcpPortalProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessMcpPortalProps {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessSchemasAllowAuthenticateViaWarp>,
    /// allowed_idps property.
    pub allowed_idps: Option<Vec<String>>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessSchemasAutoRedirectToIdentity>,
    /// custom_deny_message property.
    pub custom_deny_message: Option<AccessCustomDenyMessage>,
    /// custom_deny_url property.
    pub custom_deny_url: Option<AccessCustomDenyUrl>,
    /// custom_non_identity_deny_url property.
    pub custom_non_identity_deny_url: Option<AccessCustomNonIdentityDenyUrl>,
    /// custom_pages property.
    pub custom_pages: Option<Vec<String>>,
    /// destinations property.
    pub destinations: Option<Vec<serde_json::Value>>,
    /// domain property.
    pub domain: Option<AccessDomain>,
    /// http_only_cookie_attribute property.
    pub http_only_cookie_attribute: Option<AccessHttpOnlyCookieAttribute>,
    /// logo_url property.
    pub logo_url: Option<AccessLogoUrl>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// oauth_configuration property.
    pub oauth_configuration: Option<AccessOauthConfiguration>,
    /// options_preflight_bypass property.
    pub options_preflight_bypass: Option<AccessOptionsPreflightBypass>,
    /// same_site_cookie_attribute property.
    pub same_site_cookie_attribute: Option<AccessSameSiteCookieAttribute>,
    /// scim_config property.
    pub scim_config: Option<AccessScimConfig>,
    /// session_duration property.
    pub session_duration: Option<AccessSchemasSessionDuration>,
    /// tags property.
    pub tags: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: serde_json::Value,
}

/// `AccessMcpProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessMcpProps {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessSchemasAllowAuthenticateViaWarp>,
    /// allowed_idps property.
    pub allowed_idps: Option<Vec<String>>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessSchemasAutoRedirectToIdentity>,
    /// custom_deny_message property.
    pub custom_deny_message: Option<AccessCustomDenyMessage>,
    /// custom_deny_url property.
    pub custom_deny_url: Option<AccessCustomDenyUrl>,
    /// custom_non_identity_deny_url property.
    pub custom_non_identity_deny_url: Option<AccessCustomNonIdentityDenyUrl>,
    /// custom_pages property.
    pub custom_pages: Option<Vec<String>>,
    /// destinations property.
    pub destinations: Option<Vec<serde_json::Value>>,
    /// http_only_cookie_attribute property.
    pub http_only_cookie_attribute: Option<AccessHttpOnlyCookieAttribute>,
    /// logo_url property.
    pub logo_url: Option<AccessLogoUrl>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// oauth_configuration property.
    pub oauth_configuration: Option<AccessOauthConfiguration>,
    /// options_preflight_bypass property.
    pub options_preflight_bypass: Option<AccessOptionsPreflightBypass>,
    /// same_site_cookie_attribute property.
    pub same_site_cookie_attribute: Option<AccessSameSiteCookieAttribute>,
    /// scim_config property.
    pub scim_config: Option<AccessScimConfig>,
    /// session_duration property.
    pub session_duration: Option<AccessSchemasSessionDuration>,
    /// tags property.
    pub tags: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: serde_json::Value,
}

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

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

/// `AccessMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessMeta {
    /// created property.
    pub created: Option<String>,
    /// lastModified property.
    #[serde(rename = "lastModified")]
    pub last_modified: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

/// `AccessOidcSaasApp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessOidcSaasApp {
    /// access_token_lifetime property.
    pub access_token_lifetime: Option<String>,
    /// allow_pkce_without_client_secret property.
    pub allow_pkce_without_client_secret: Option<bool>,
    /// app_launcher_url property.
    pub app_launcher_url: Option<String>,
    /// auth_type property.
    pub auth_type: Option<String>,
    /// client_id property.
    pub client_id: Option<String>,
    /// client_secret property.
    pub client_secret: Option<String>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// custom_claims property.
    pub custom_claims: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
    /// grant_types property.
    pub grant_types: Option<Vec<String>>,
    /// group_filter_regex property.
    pub group_filter_regex: Option<String>,
    /// hybrid_and_implicit_options property.
    pub hybrid_and_implicit_options: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// public_key property.
    pub public_key: Option<String>,
    /// redirect_uris property.
    pub redirect_uris: Option<Vec<String>>,
    /// refresh_token_options property.
    pub refresh_token_options: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// scopes property.
    pub scopes: Option<Vec<String>>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

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

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

/// `AccessOnetimepin` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessOnetimepin {
    /// `config` property.
    pub config: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<String>,
}

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

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

/// `AccessOrganizations` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessOrganizations {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessAllowAuthenticateViaWarp>,
    /// auth_domain property.
    pub auth_domain: Option<AccessAuthDomain>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessAutoRedirectToIdentity>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// custom_pages property.
    pub custom_pages: Option<AccessCustomPages>,
    /// deny_unmatched_requests property.
    pub deny_unmatched_requests: Option<AccessDenyUnmatchedRequests>,
    /// deny_unmatched_requests_exempted_zone_names property.
    pub deny_unmatched_requests_exempted_zone_names: Option<Vec<String>>,
    /// is_ui_read_only property.
    pub is_ui_read_only: Option<AccessIsUiReadOnly>,
    /// login_design property.
    pub login_design: Option<AccessLoginDesign>,
    /// mfa_config property.
    pub mfa_config: Option<AccessOrgMfaConfig>,
    /// mfa_required_for_all_apps property.
    pub mfa_required_for_all_apps: Option<AccessMfaRequiredForAllApps>,
    /// name property.
    pub name: Option<AccessName>,
    /// session_duration property.
    pub session_duration: Option<AccessSessionDuration>,
    /// ui_read_only_toggle_reason property.
    pub ui_read_only_toggle_reason: Option<AccessUiReadOnlyToggleReason>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
    /// user_seat_expiration_inactive_time property.
    pub user_seat_expiration_inactive_time: Option<AccessUserSeatExpirationInactiveTime>,
    /// warp_auth_session_duration property.
    pub warp_auth_session_duration: Option<AccessWarpAuthSessionDuration>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessPolicyUsers` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessPolicyUsers {
    /// email property.
    pub email: Option<AccessSchemasEmail>,
    /// id property.
    pub id: Option<AccessUuid>,
    /// name property.
    pub name: Option<AccessUsersComponentsSchemasName>,
    /// status property.
    pub status: Option<AccessUserResult>,
}

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

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

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

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

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

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

/// `AccessProxyEndpointProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessProxyEndpointProps {
    /// `domain` property.
    pub domain: Option<serde_json::Value>,
    /// `name` property.
    pub name: Option<serde_json::Value>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

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

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

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

/// `AccessRdpProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessRdpProps {
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

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

/// `AccessResponses` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessResponses {
    /// cf_resource_id property.
    pub cf_resource_id: Option<String>,
    /// error_description property.
    pub error_description: Option<String>,
    /// idp_id property.
    pub idp_id: Option<String>,
    /// idp_resource_id property.
    pub idp_resource_id: Option<String>,
    /// logged_at property.
    pub logged_at: Option<AccessTimestamp>,
    /// request_body property.
    pub request_body: Option<String>,
    /// request_method property.
    pub request_method: Option<String>,
    /// resource_group_name property.
    pub resource_group_name: Option<String>,
    /// resource_type property.
    pub resource_type: Option<String>,
    /// resource_user_email property.
    pub resource_user_email: Option<String>,
    /// status property.
    pub status: Option<String>,
}

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

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

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

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

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

/// `AccessSaasProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSaasProps {
    /// allowed_idps property.
    pub allowed_idps: Option<Vec<String>>,
    /// app_launcher_visible property.
    pub app_launcher_visible: Option<AccessAppLauncherVisible>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessSchemasAutoRedirectToIdentity>,
    /// custom_pages property.
    pub custom_pages: Option<Vec<String>>,
    /// logo_url property.
    pub logo_url: Option<AccessLogoUrl>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// saas_app property.
    pub saas_app: Option<serde_json::Value>,
    /// scim_config property.
    pub scim_config: Option<AccessScimConfig>,
    /// tags property.
    pub tags: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

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

/// `AccessSamlSaasApp` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSamlSaasApp {
    /// auth_type property.
    pub auth_type: Option<String>,
    /// consumer_service_url property.
    pub consumer_service_url: Option<String>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// custom_attributes property.
    pub custom_attributes: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
    /// default_relay_state property.
    pub default_relay_state: Option<String>,
    /// idp_entity_id property.
    pub idp_entity_id: Option<String>,
    /// name_id_format property.
    pub name_id_format: Option<String>,
    /// name_id_transform_jsonata property.
    pub name_id_transform_jsonata: Option<String>,
    /// public_key property.
    pub public_key: Option<String>,
    /// saml_attribute_transform_jsonata property.
    pub saml_attribute_transform_jsonata: Option<String>,
    /// sp_entity_id property.
    pub sp_entity_id: Option<String>,
    /// sso_endpoint property.
    pub sso_endpoint: Option<String>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

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

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

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

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

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

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

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

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

/// `AccessSchemasGroups` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSchemasGroups {
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// exclude property.
    pub exclude: Option<Vec<AccessRule>>,
    /// id property.
    pub id: Option<AccessUuid>,
    /// include property.
    pub include: Option<Vec<AccessRule>>,
    /// is_default property.
    pub is_default: Option<Vec<AccessRule>>,
    /// name property.
    pub name: Option<AccessGroupsComponentsSchemasName>,
    /// require property.
    pub require: Option<Vec<AccessRule>>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

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

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

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

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

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

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

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

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

/// `AccessSchemasUsers` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSchemasUsers {
    /// access_seat property.
    pub access_seat: Option<AccessSchemasAccessSeat>,
    /// active_device_count property.
    pub active_device_count: Option<AccessActiveDeviceCount>,
    /// created_at property.
    pub created_at: Option<AccessTimestamp>,
    /// email property.
    pub email: Option<AccessSchemasEmail>,
    /// gateway_seat property.
    pub gateway_seat: Option<AccessSchemasGatewaySeat>,
    /// id property.
    pub id: Option<AccessUuid>,
    /// last_successful_login property.
    pub last_successful_login: Option<AccessLastSuccessfulLogin>,
    /// name property.
    pub name: Option<AccessUsersComponentsSchemasName>,
    /// seat_uid property.
    pub seat_uid: Option<AccessSchemasSeatUid>,
    /// uid property.
    pub uid: Option<AccessUid>,
    /// updated_at property.
    pub updated_at: Option<AccessTimestamp>,
}

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

/// `AccessScimConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessScimConfig {
    /// authentication property.
    pub authentication: Option<serde_json::Value>,
    /// deactivate_on_delete property.
    pub deactivate_on_delete: Option<bool>,
    /// enabled property.
    pub enabled: Option<bool>,
    /// idp_uid property.
    pub idp_uid: String,
    /// mappings property.
    pub mappings: Option<Vec<AccessScimConfigMapping>>,
    /// remote_uri property.
    pub remote_uri: String,
}

/// `AccessScimConfigMapping` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessScimConfigMapping {
    /// enabled property.
    pub enabled: Option<bool>,
    /// filter property.
    pub filter: Option<String>,
    /// operations property.
    pub operations: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// schema property.
    pub schema: String,
    /// strictness property.
    pub strictness: Option<String>,
    /// transform_jsonata property.
    pub transform_jsonata: Option<String>,
}

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

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

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

/// `AccessSeat` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSeat {
    /// access_seat property.
    pub access_seat: AccessAccessSeat,
    /// gateway_seat property.
    pub gateway_seat: AccessGatewaySeat,
    /// seat_uid property.
    pub seat_uid: AccessSeatUid,
}

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

/// `AccessSeats` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSeats {
    /// access_seat property.
    pub access_seat: Option<AccessAccessSeat>,
    /// created_at property.
    pub created_at: Option<AccessTimestamp>,
    /// gateway_seat property.
    pub gateway_seat: Option<AccessGatewaySeat>,
    /// seat_uid property.
    pub seat_uid: Option<AccessSeatUid>,
    /// updated_at property.
    pub updated_at: Option<AccessTimestamp>,
}

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

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

/// `AccessSelfHostedProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSelfHostedProps {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessSchemasAllowAuthenticateViaWarp>,
    /// allow_iframe property.
    pub allow_iframe: Option<AccessAllowIframe>,
    /// allowed_idps property.
    pub allowed_idps: Option<Vec<String>>,
    /// app_launcher_visible property.
    pub app_launcher_visible: Option<AccessAppLauncherVisible>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessSchemasAutoRedirectToIdentity>,
    /// cors_headers property.
    pub cors_headers: Option<AccessCorsHeaders>,
    /// custom_deny_message property.
    pub custom_deny_message: Option<AccessCustomDenyMessage>,
    /// custom_deny_url property.
    pub custom_deny_url: Option<AccessCustomDenyUrl>,
    /// custom_non_identity_deny_url property.
    pub custom_non_identity_deny_url: Option<AccessCustomNonIdentityDenyUrl>,
    /// custom_pages property.
    pub custom_pages: Option<Vec<String>>,
    /// destinations property.
    pub destinations: Option<Vec<serde_json::Value>>,
    /// domain property.
    pub domain: AccessDomain,
    /// enable_binding_cookie property.
    pub enable_binding_cookie: Option<AccessEnableBindingCookie>,
    /// http_only_cookie_attribute property.
    pub http_only_cookie_attribute: Option<AccessHttpOnlyCookieAttribute>,
    /// logo_url property.
    pub logo_url: Option<AccessLogoUrl>,
    /// mfa_config property.
    pub mfa_config: Option<AccessMfaConfig>,
    /// name property.
    pub name: Option<AccessAppsComponentsSchemasName>,
    /// oauth_configuration property.
    pub oauth_configuration: Option<AccessOauthConfiguration>,
    /// options_preflight_bypass property.
    pub options_preflight_bypass: Option<AccessOptionsPreflightBypass>,
    /// path_cookie_attribute property.
    pub path_cookie_attribute: Option<AccessPathCookieAttribute>,
    /// read_service_tokens_from_header property.
    pub read_service_tokens_from_header: Option<AccessReadServiceTokensFromHeader>,
    /// same_site_cookie_attribute property.
    pub same_site_cookie_attribute: Option<AccessSameSiteCookieAttribute>,
    /// scim_config property.
    pub scim_config: Option<AccessScimConfig>,
    /// self_hosted_domains property.
    pub self_hosted_domains: Option<Vec<String>>,
    /// service_auth_401_redirect property.
    pub service_auth_401_redirect: Option<AccessServiceAuth401Redirect>,
    /// session_duration property.
    pub session_duration: Option<AccessSchemasSessionDuration>,
    /// skip_interstitial property.
    pub skip_interstitial: Option<AccessSkipInterstitial>,
    /// tags property.
    pub tags: Option<Vec<String>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: serde_json::Value,
    /// use_clientless_isolation_app_launcher_url property.
    pub use_clientless_isolation_app_launcher_url: Option<AccessUseClientlessIsolationAppLauncherUrl>,
}

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

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

/// `AccessServiceTokens` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessServiceTokens {
    /// client_id property.
    pub client_id: Option<AccessClientId>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// duration property.
    pub duration: Option<AccessDuration>,
    /// expires_at property.
    pub expires_at: Option<AccessTimestamp>,
    /// id property.
    pub id: Option<serde_json::Value>,
    /// last_seen_at property.
    pub last_seen_at: Option<serde_json::Value>,
    /// name property.
    pub name: Option<AccessSchemasName>,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

/// `AccessServiceTokensCreateAServiceTokenRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessServiceTokensCreateAServiceTokenRequest {
    /// client_secret_version property.
    pub client_secret_version: Option<AccessClientSecretVersion>,
    /// duration property.
    pub duration: Option<AccessDuration>,
    /// name property.
    pub name: AccessSchemasName,
    /// previous_client_secret_expires_at property.
    pub previous_client_secret_expires_at: Option<AccessPreviousClientSecretExpiresAt>,
}

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

/// `AccessServiceTokensUpdateAServiceTokenRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessServiceTokensUpdateAServiceTokenRequest {
    /// client_secret_version property.
    pub client_secret_version: Option<AccessClientSecretVersion>,
    /// duration property.
    pub duration: Option<AccessDuration>,
    /// name property.
    pub name: Option<AccessSchemasName>,
    /// previous_client_secret_expires_at property.
    pub previous_client_secret_expires_at: Option<AccessPreviousClientSecretExpiresAt>,
}

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

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

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

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

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

/// `AccessSshProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessSshProps {
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

/// `AccessTag` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessTag {
    /// app_count property.
    pub app_count: Option<i64>,
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// name property.
    pub name: AccessTagsComponentsSchemasName,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

/// `AccessTagWithoutAppCount` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessTagWithoutAppCount {
    /// created_at property.
    pub created_at: Option<AccessCreatedAt>,
    /// name property.
    pub name: AccessTagsComponentsSchemasName,
    /// updated_at property.
    pub updated_at: Option<AccessUpdatedAt>,
}

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

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

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

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

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

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

/// `AccessTargetCriteriaBase` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessTargetCriteriaBase {
    /// port property.
    pub port: AccessPort,
    /// target_attributes property.
    pub target_attributes: AccessTargetAttributes,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `AccessUsers` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessUsers {
    /// active property.
    pub active: Option<bool>,
    /// displayName property.
    #[serde(rename = "displayName")]
    pub display_name: Option<String>,
    /// emails property.
    pub emails: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
    /// externalId property.
    #[serde(rename = "externalId")]
    pub external_id: Option<String>,
    /// id property.
    pub id: Option<AccessId>,
    /// meta property.
    pub meta: Option<AccessMeta>,
    /// schemas property.
    pub schemas: Option<Vec<String>>,
}

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

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

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

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

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

/// `AccessVncProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessVncProps {
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

/// `AccessWarpProps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct AccessWarpProps {
    /// `domain` property.
    pub domain: Option<serde_json::Value>,
    /// `name` property.
    pub name: Option<serde_json::Value>,
    /// `type` property.
    #[serde(rename = "type")]
    pub r#type: Option<serde_json::Value>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `DlpRiskEvent` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpRiskEvent {
    /// event_details property.
    pub event_details: Option<serde_json::Value>,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// risk_level property.
    pub risk_level: DlpRiskLevel,
    /// timestamp property.
    pub timestamp: String,
}

/// `DlpRiskEvents` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpRiskEvents {
    /// email property.
    pub email: String,
    /// events property.
    pub events: Vec<DlpRiskEvent>,
    /// last_reset_time property.
    pub last_reset_time: Option<String>,
    /// name property.
    pub name: String,
    /// risk_level property.
    pub risk_level: Option<serde_json::Value>,
}

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

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

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

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

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

/// `IamAccount` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamAccount {
    /// created_on property.
    pub created_on: Option<String>,
    /// id property.
    pub id: IamCommonComponentsSchemasIdentifier,
    /// managed_by property.
    pub managed_by: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// name property.
    pub name: String,
    /// settings property.
    pub settings: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: IamAccountType,
}

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

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

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

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

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

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

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

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

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

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

/// `IamCreateMemberPolicy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamCreateMemberPolicy {
    /// access property.
    pub access: IamAccess,
    /// id property.
    pub id: IamPolicyIdentifier,
    /// permission_groups property.
    pub permission_groups: Vec<IamMemberPermissionGroup>,
    /// resource_groups property.
    pub resource_groups: Vec<IamMemberResourceGroup>,
}

/// `IamCreateMemberWithPolicies` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamCreateMemberWithPolicies {
    /// email property.
    pub email: IamEmail,
    /// policies property.
    pub policies: Vec<IamCreateMemberPolicy>,
    /// status property.
    pub status: Option<IamMemberInvitationStatus>,
}

/// `IamCreateMemberWithRoles` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamCreateMemberWithRoles {
    /// email property.
    pub email: IamEmail,
    /// roles property.
    pub roles: Vec<IamRoleComponentsSchemasIdentifier>,
    /// status property.
    pub status: Option<IamMemberInvitationStatus>,
}

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

/// `IamCreateResourceGroupScopeScopeObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamCreateResourceGroupScopeScopeObject {
    /// key property.
    pub key: IamCreateResourceGroupScopeScopeObjectKey,
}

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

/// `IamCreateScope` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamCreateScope {
    /// key property.
    pub key: IamCreateResourceGroupScopeScopeKey,
    /// objects property.
    pub objects: Vec<IamCreateResourceGroupScopeScopeObject>,
}

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

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

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

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

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

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

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

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

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

/// `IamListMemberPolicy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamListMemberPolicy {
    /// access property.
    pub access: Option<IamAccess>,
    /// id property.
    pub id: Option<IamPolicyIdentifier>,
    /// permission_groups property.
    pub permission_groups: Option<Vec<IamPermissionGroup>>,
    /// resource_groups property.
    pub resource_groups: Option<Vec<IamResourceGroup>>,
}

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

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

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

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

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

/// `IamMemberWithPolicies` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamMemberWithPolicies {
    /// email property.
    pub email: Option<IamEmail>,
    /// id property.
    pub id: Option<IamMembershipComponentsSchemasIdentifier>,
    /// policies property.
    pub policies: Option<Vec<IamListMemberPolicy>>,
    /// roles property.
    pub roles: Option<Vec<IamRole>>,
    /// status property.
    pub status: Option<serde_json::Value>,
    /// user property.
    pub user: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `IamMembership` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamMembership {
    /// account property.
    pub account: Option<IamSchemasAccount>,
    /// api_access_enabled property.
    pub api_access_enabled: Option<IamApiAccessEnabled>,
    /// id property.
    pub id: Option<IamMembershipComponentsSchemasIdentifier>,
    /// permissions property.
    pub permissions: Option<serde_json::Value>,
    /// roles property.
    pub roles: Option<Vec<String>>,
    /// status property.
    pub status: Option<IamSchemasStatus>,
}

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

/// `IamMembershipWithPolicies` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamMembershipWithPolicies {
    /// account property.
    pub account: Option<IamSchemasAccount>,
    /// api_access_enabled property.
    pub api_access_enabled: Option<IamApiAccessEnabled>,
    /// id property.
    pub id: Option<IamMembershipComponentsSchemasIdentifier>,
    /// permissions property.
    pub permissions: Option<serde_json::Value>,
    /// policies property.
    pub policies: Option<Vec<IamListMemberPolicy>>,
    /// roles property.
    pub roles: Option<Vec<String>>,
    /// status property.
    pub status: Option<IamSchemasStatus>,
}

/// `IamOrganization` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamOrganization {
    /// id property.
    pub id: Option<IamCommonComponentsSchemasIdentifier>,
    /// name property.
    pub name: Option<IamSchemasName>,
    /// permissions property.
    pub permissions: Option<Vec<String>>,
    /// roles property.
    pub roles: Option<Vec<String>>,
    /// status property.
    pub status: Option<IamComponentsSchemasStatus>,
}

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

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

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

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

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

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

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

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

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

/// `IamRole` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamRole {
    /// description property.
    pub description: String,
    /// id property.
    pub id: IamRoleComponentsSchemasIdentifier,
    /// name property.
    pub name: String,
    /// permissions property.
    pub permissions: serde_json::Value,
}

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

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

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

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

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

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

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

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

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

/// `IamScope` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamScope {
    /// key property.
    pub key: IamScopeKey,
    /// objects property.
    pub objects: Vec<IamScopeObject>,
}

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

/// `IamScopeObject` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamScopeObject {
    /// key property.
    pub key: IamScopeObjectKey,
}

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

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

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

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

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

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

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

/// `IamSsoConnector` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamSsoConnector {
    /// created_on property.
    pub created_on: Option<String>,
    /// email_domain property.
    pub email_domain: Option<String>,
    /// enabled property.
    pub enabled: Option<bool>,
    /// id property.
    pub id: Option<IamSsoConnectorIdentifier>,
    /// updated_on property.
    pub updated_on: Option<String>,
    /// use_fedramp_language property.
    pub use_fedramp_language: Option<IamUseFedrampLanguage>,
    /// verification property.
    pub verification: Option<IamSsoConnectorVerificationInfo>,
}

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

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

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

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

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

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

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

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

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

/// `IamUpdateMemberWithRoles` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamUpdateMemberWithRoles {
    /// id property.
    pub id: Option<IamMembershipComponentsSchemasIdentifier>,
    /// roles property.
    pub roles: Option<Vec<IamRole>>,
    /// status property.
    pub status: Option<serde_json::Value>,
    /// user property.
    pub user: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

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

/// `IamUserGroup` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamUserGroup {
    /// created_on property.
    pub created_on: String,
    /// id property.
    pub id: IamUserGroupIdentifier,
    /// modified_on property.
    pub modified_on: String,
    /// name property.
    pub name: String,
    /// policies property.
    pub policies: Option<Vec<serde_json::Value>>,
}

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

/// `IamUserGroupMember` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamUserGroupMember {
    /// email property.
    pub email: Option<IamEmail>,
    /// id property.
    pub id: String,
    /// status property.
    pub status: Option<serde_json::Value>,
}

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

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

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

/// `IamUserInvite` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct IamUserInvite {
    /// expires_on property.
    pub expires_on: Option<IamSchemasExpiresOn>,
    /// id property.
    pub id: Option<IamInviteComponentsSchemasIdentifier>,
    /// invited_by property.
    pub invited_by: Option<IamInvitedBy>,
    /// invited_member_email property.
    pub invited_member_email: Option<IamInvitedMemberEmail>,
    /// invited_member_id property.
    pub invited_member_id: Option<String>,
    /// invited_on property.
    pub invited_on: Option<IamInvitedOn>,
    /// organization_id property.
    pub organization_id: String,
    /// organization_is_enforcing_twofactor property.
    pub organization_is_enforcing_twofactor: Option<bool>,
    /// organization_name property.
    pub organization_name: Option<String>,
    /// roles property.
    pub roles: Option<Vec<String>>,
    /// status property.
    pub status: Option<serde_json::Value>,
}

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

/// `InitNewSsoConnectorRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct InitNewSsoConnectorRequest {
    /// begin_verification property.
    pub begin_verification: Option<bool>,
    /// email_domain property.
    pub email_domain: String,
    /// use_fedramp_language property.
    pub use_fedramp_language: Option<IamUseFedrampLanguage>,
}

/// `ListAbuseReportsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListAbuseReportsResponse {
    /// errors property.
    pub errors: Option<Vec<AbuseReportsMessage>>,
    /// messages property.
    pub messages: Option<Vec<AbuseReportsMessage>>,
    /// result property.
    pub result: Option<ListAbuseReportsResponseResult>,
    /// result_info property.
    pub result_info: Option<ListAbuseReportsResponseResultInfo>,
    /// success property.
    pub success: bool,
}

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

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

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

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

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

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

/// `LoadBalancerPoolsCreatePoolRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancerPoolsCreatePoolRequest {
    /// check_regions property.
    pub check_regions: Option<Vec<String>>,
    /// 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,
    /// networks property.
    pub networks: Option<Vec<String>>,
    /// 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>,
}

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

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

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

/// `LoadBalancerPoolsUpdatePoolRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancerPoolsUpdatePoolRequest {
    /// 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,
    /// networks property.
    pub networks: Option<Vec<String>>,
    /// 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>,
}

/// `LoadBalancingAnalytics` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancingAnalytics {
    /// id property.
    pub id: Option<i64>,
    /// origins property.
    pub origins: Option<Vec<LoadBalancingOriginAnalytics>>,
    /// pool property.
    pub pool: Option<serde_json::Value>,
    /// timestamp property.
    pub timestamp: Option<String>,
}

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

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

/// `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>,
}

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

/// `LoadBalancingOriginAnalytics` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct LoadBalancingOriginAnalytics {
    /// address property.
    pub address: Option<LoadBalancingAddress>,
    /// changed property.
    pub changed: Option<LoadBalancingOriginChanged>,
    /// enabled property.
    pub enabled: Option<LoadBalancingSchemasEnabled>,
    /// failure_reason property.
    pub failure_reason: Option<LoadBalancingOriginFailureReason>,
    /// healthy property.
    pub healthy: Option<LoadBalancingOriginHealthy>,
    /// ip property.
    pub ip: Option<LoadBalancingOriginIp>,
    /// name property.
    pub name: Option<LoadBalancingSchemasName>,
}

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

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

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

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

/// `McpPortalsApiCreatePortalsRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiCreatePortalsRequest {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
    /// servers property.
    pub servers: Option<Vec<McpPortalsApiCreatePortalsRequestServersItem>>,
}

/// `McpPortalsApiCreatePortalsRequestServersItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiCreatePortalsRequestServersItem {
    /// default_disabled property.
    pub default_disabled: Option<bool>,
    /// on_behalf property.
    pub on_behalf: Option<bool>,
    /// server_id property.
    pub server_id: String,
    /// updated_prompts property.
    pub updated_prompts: Option<Vec<McpPortalsApiCreatePortalsRequestServersItemUpdatedPromptsItem>>,
    /// updated_tools property.
    pub updated_tools: Option<Vec<McpPortalsApiCreatePortalsRequestServersItemUpdatedToolsItem>>,
}

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

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

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

/// `McpPortalsApiCreatePortalsResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiCreatePortalsResponseResult {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
}

/// `McpPortalsApiCreateServersRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiCreateServersRequest {
    /// auth_credentials property.
    pub auth_credentials: Option<String>,
    /// auth_type property.
    pub auth_type: String,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
}

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

/// `McpPortalsApiCreateServersResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiCreateServersResponseResult {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiDeletePortalsResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiDeletePortalsResponseResult {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
}

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

/// `McpPortalsApiDeleteServersResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiDeleteServersResponseResult {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiFetchGatewaysResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiFetchGatewaysResponseResult {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
    /// servers property.
    pub servers: Vec<McpPortalsApiFetchGatewaysResponseResultServersItem>,
}

/// `McpPortalsApiFetchGatewaysResponseResultServersItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiFetchGatewaysResponseResultServersItem {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// default_disabled property.
    pub default_disabled: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// on_behalf property.
    pub on_behalf: Option<bool>,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
    /// updated_prompts property.
    pub updated_prompts: Vec<serde_json::Value>,
    /// updated_tools property.
    pub updated_tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiFetchServersResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiFetchServersResponseResult {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiListPortalsResponseResultItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiListPortalsResponseResultItem {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
    /// servers property.
    pub servers: Vec<McpPortalsApiListPortalsResponseResultItemServersItem>,
}

/// `McpPortalsApiListPortalsResponseResultItemServersItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiListPortalsResponseResultItemServersItem {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// default_disabled property.
    pub default_disabled: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// on_behalf property.
    pub on_behalf: Option<bool>,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
    /// updated_prompts property.
    pub updated_prompts: Vec<serde_json::Value>,
    /// updated_tools property.
    pub updated_tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiListServersResponseResultItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiListServersResponseResultItem {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
}

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

/// `McpPortalsApiUpdatePortalsRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiUpdatePortalsRequest {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: Option<String>,
    /// name property.
    pub name: Option<String>,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
    /// servers property.
    pub servers: Option<Vec<McpPortalsApiUpdatePortalsRequestServersItem>>,
}

/// `McpPortalsApiUpdatePortalsRequestServersItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiUpdatePortalsRequestServersItem {
    /// default_disabled property.
    pub default_disabled: Option<bool>,
    /// on_behalf property.
    pub on_behalf: Option<bool>,
    /// server_id property.
    pub server_id: String,
    /// updated_prompts property.
    pub updated_prompts: Option<Vec<McpPortalsApiUpdatePortalsRequestServersItemUpdatedPromptsItem>>,
    /// updated_tools property.
    pub updated_tools: Option<Vec<McpPortalsApiUpdatePortalsRequestServersItemUpdatedToolsItem>>,
}

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

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

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

/// `McpPortalsApiUpdatePortalsResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiUpdatePortalsResponseResult {
    /// allow_code_mode property.
    pub allow_code_mode: Option<bool>,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// secure_web_gateway property.
    pub secure_web_gateway: Option<bool>,
}

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

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

/// `McpPortalsApiUpdateServersResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct McpPortalsApiUpdateServersResponseResult {
    /// auth_type property.
    pub auth_type: String,
    /// created_at property.
    pub created_at: Option<String>,
    /// created_by property.
    pub created_by: Option<String>,
    /// description property.
    pub description: Option<String>,
    /// error property.
    pub error: Option<String>,
    /// hostname property.
    pub hostname: String,
    /// id property.
    pub id: String,
    /// last_successful_sync property.
    pub last_successful_sync: Option<String>,
    /// last_synced property.
    pub last_synced: Option<String>,
    /// modified_at property.
    pub modified_at: Option<String>,
    /// modified_by property.
    pub modified_by: Option<String>,
    /// name property.
    pub name: String,
    /// prompts property.
    pub prompts: Vec<serde_json::Value>,
    /// status property.
    pub status: Option<String>,
    /// tools property.
    pub tools: Vec<serde_json::Value>,
}

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

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

/// `MembersDeleteRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MembersDeleteRequest {
    /// member_id property.
    pub member_id: OrganizationsApiMemberID,
}

/// `MembersListResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MembersListResponse {
    /// errors property.
    pub errors: Vec<serde_json::Value>,
    /// messages property.
    pub messages: Vec<OrganizationsApiV4Message>,
    /// result property.
    pub result: Vec<OrganizationsApiMember>,
    /// result_info property.
    pub result_info: OrganizationsApiPageTokenResultInfo,
    /// success property.
    pub success: bool,
}

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

/// `OrganizationListOrganizationsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationListOrganizationsResponse {
    /// errors property.
    pub errors: Vec<serde_json::Value>,
    /// messages property.
    pub messages: Vec<OrganizationsApiV4Message>,
    /// result property.
    pub result: Vec<OrganizationsApiOrganization>,
    /// result_info property.
    pub result_info: OrganizationsApiPageTokenResultInfo,
    /// success property.
    pub success: bool,
}

/// `OrganizationsApiAccount` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationsApiAccount {
    /// created_on property.
    pub created_on: String,
    /// id property.
    pub id: String,
    /// name property.
    pub name: Option<String>,
    /// settings property.
    pub settings: std::collections::HashMap<String, serde_json::Value>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: String,
}

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

/// `OrganizationsApiCreateMemberRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationsApiCreateMemberRequest {
    /// member property.
    pub member: OrganizationsApiCreateSingleMember,
}

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

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

/// `OrganizationsApiMember` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationsApiMember {
    /// create_time property.
    pub create_time: String,
    /// id property.
    pub id: OrganizationsApiMemberID,
    /// meta property.
    pub meta: serde_json::Value,
    /// status property.
    pub status: String,
    /// update_time property.
    pub update_time: String,
    /// user property.
    pub user: OrganizationsApiMemberSubjectUser,
}

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

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

/// `OrganizationsApiOrganization` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationsApiOrganization {
    /// create_time property.
    pub create_time: String,
    /// id property.
    pub id: serde_json::Value,
    /// meta property.
    pub meta: std::collections::HashMap<String, serde_json::Value>,
    /// name property.
    pub name: String,
    /// parent property.
    pub parent: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// profile property.
    pub profile: Option<OrganizationsApiProfile>,
}

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

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

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

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

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

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

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

/// `OrganizationsGetAccountsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct OrganizationsGetAccountsResponse {
    /// errors property.
    pub errors: Vec<serde_json::Value>,
    /// messages property.
    pub messages: Vec<OrganizationsApiV4Message>,
    /// result property.
    pub result: Vec<OrganizationsApiAccount>,
    /// result_info property.
    pub result_info: OrganizationsApiPageTokenResultInfo,
    /// success property.
    pub success: bool,
}

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

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

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

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

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

/// `UserEditUserRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct UserEditUserRequest {
    /// country property.
    pub country: Option<IamCountry>,
    /// first_name property.
    pub first_name: Option<IamFirstName>,
    /// last_name property.
    pub last_name: Option<IamLastName>,
    /// telephone property.
    pub telephone: Option<IamTelephone>,
    /// zipcode property.
    pub zipcode: Option<IamZipcode>,
}

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

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

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

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

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

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

/// `ZeroTrustOrganizationCreateYourZeroTrustOrganizationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustOrganizationCreateYourZeroTrustOrganizationRequest {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessAllowAuthenticateViaWarp>,
    /// auth_domain property.
    pub auth_domain: AccessAuthDomain,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessAutoRedirectToIdentity>,
    /// deny_unmatched_requests property.
    pub deny_unmatched_requests: Option<AccessDenyUnmatchedRequests>,
    /// deny_unmatched_requests_exempted_zone_names property.
    pub deny_unmatched_requests_exempted_zone_names: Option<Vec<String>>,
    /// is_ui_read_only property.
    pub is_ui_read_only: Option<AccessIsUiReadOnly>,
    /// login_design property.
    pub login_design: Option<AccessLoginDesign>,
    /// mfa_config property.
    pub mfa_config: Option<AccessOrgMfaConfig>,
    /// mfa_required_for_all_apps property.
    pub mfa_required_for_all_apps: Option<AccessMfaRequiredForAllApps>,
    /// name property.
    pub name: AccessName,
    /// session_duration property.
    pub session_duration: Option<AccessSessionDuration>,
    /// ui_read_only_toggle_reason property.
    pub ui_read_only_toggle_reason: Option<AccessUiReadOnlyToggleReason>,
    /// user_seat_expiration_inactive_time property.
    pub user_seat_expiration_inactive_time: Option<AccessUserSeatExpirationInactiveTime>,
    /// warp_auth_session_duration property.
    pub warp_auth_session_duration: Option<AccessWarpAuthSessionDuration>,
}

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

/// `ZeroTrustOrganizationRevokeAllAccessTokensForAUserRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustOrganizationRevokeAllAccessTokensForAUserRequest {
    /// devices property.
    pub devices: Option<bool>,
    /// email property.
    pub email: String,
    /// user_uid property.
    pub user_uid: Option<String>,
    /// warp_session_reauth property.
    pub warp_session_reauth: Option<bool>,
}

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

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

/// `ZeroTrustOrganizationUpdateYourZeroTrustOrganizationRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustOrganizationUpdateYourZeroTrustOrganizationRequest {
    /// allow_authenticate_via_warp property.
    pub allow_authenticate_via_warp: Option<AccessAllowAuthenticateViaWarp>,
    /// auth_domain property.
    pub auth_domain: Option<AccessAuthDomain>,
    /// auto_redirect_to_identity property.
    pub auto_redirect_to_identity: Option<AccessAutoRedirectToIdentity>,
    /// custom_pages property.
    pub custom_pages: Option<AccessCustomPages>,
    /// deny_unmatched_requests property.
    pub deny_unmatched_requests: Option<AccessDenyUnmatchedRequests>,
    /// deny_unmatched_requests_exempted_zone_names property.
    pub deny_unmatched_requests_exempted_zone_names: Option<Vec<String>>,
    /// is_ui_read_only property.
    pub is_ui_read_only: Option<AccessIsUiReadOnly>,
    /// login_design property.
    pub login_design: Option<AccessLoginDesign>,
    /// mfa_config property.
    pub mfa_config: Option<AccessOrgMfaConfig>,
    /// mfa_required_for_all_apps property.
    pub mfa_required_for_all_apps: Option<AccessMfaRequiredForAllApps>,
    /// name property.
    pub name: Option<AccessName>,
    /// session_duration property.
    pub session_duration: Option<AccessSessionDuration>,
    /// ui_read_only_toggle_reason property.
    pub ui_read_only_toggle_reason: Option<AccessUiReadOnlyToggleReason>,
    /// user_seat_expiration_inactive_time property.
    pub user_seat_expiration_inactive_time: Option<AccessUserSeatExpirationInactiveTime>,
    /// warp_auth_session_duration property.
    pub warp_auth_session_duration: Option<AccessWarpAuthSessionDuration>,
}

/// `ZeroTrustUsersCreateUserRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ZeroTrustUsersCreateUserRequest {
    /// email property.
    pub email: AccessSchemasEmail,
    /// name property.
    pub name: Option<AccessUsersComponentsSchemasName>,
}

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

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

/// Arguments for [`ListAbuseReports_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListAbuseReportsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `sort`.
    pub sort: Option<String>,
    /// Query parameter: `domain`.
    pub domain: Option<String>,
    /// Query parameter: `created_before`.
    pub created_before: Option<String>,
    /// Query parameter: `created_after`.
    pub created_after: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `type`.
    pub r#type: Option<String>,
    /// Query parameter: `mitigation_status`.
    pub mitigation_status: Option<String>,
}

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

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

/// Arguments for [`mcp-portals-api-list-portals_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiListPortalsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
}

/// Arguments for [`mcp-portals-api-create-portals_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiCreatePortalsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McpPortalsApiCreatePortalsRequest,
}

/// Arguments for [`mcp-portals-api-fetch-gateways_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiFetchGatewaysArgs {
    /// Path parameter: `id`.
    pub id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`mcp-portals-api-update-portals_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiUpdatePortalsArgs {
    /// Path parameter: `id`.
    pub id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McpPortalsApiUpdatePortalsRequest,
}

/// Arguments for [`mcp-portals-api-delete-portals_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiDeletePortalsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
}

/// Arguments for [`mcp-portals-api-list-servers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiListServersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
}

/// Arguments for [`mcp-portals-api-create-servers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiCreateServersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McpPortalsApiCreateServersRequest,
}

/// Arguments for [`mcp-portals-api-fetch-servers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiFetchServersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
}

/// Arguments for [`mcp-portals-api-update-servers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiUpdateServersArgs {
    /// Path parameter: `id`.
    pub id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: McpPortalsApiUpdateServersRequest,
}

/// Arguments for [`mcp-portals-api-delete-servers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiDeleteServersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `id`.
    pub id: String,
}

/// Arguments for [`mcp-portals-api-sync-server_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct McpPortalsApiSyncServerArgs {
    /// Path parameter: `id`.
    pub id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-applications-list-access-applications_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsListAccessApplicationsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `domain`.
    pub domain: Option<String>,
    /// Query parameter: `aud`.
    pub aud: Option<String>,
    /// Query parameter: `target_attributes`.
    pub target_attributes: Option<String>,
    /// Query parameter: `exact`.
    pub exact: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-applications-add-an-application_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsAddAnApplicationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppRequest,
}

/// Arguments for [`access-short-lived-certificate-c-as-list-short-lived-certificate-c-as_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessShortLivedCertificateCAsListShortLivedCertificateCAsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-applications-get-an-access-application_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsGetAnAccessApplicationArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-applications-update-an-access-application_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsUpdateAnAccessApplicationArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppRequest,
}

/// Arguments for [`access-applications-delete-an-access-application_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsDeleteAnAccessApplicationArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-short-lived-certificate-c-as-get-a-short-lived-certificate-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessShortLivedCertificateCAsGetAShortLivedCertificateCaArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-short-lived-certificate-c-as-create-a-short-lived-certificate-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessShortLivedCertificateCAsCreateAShortLivedCertificateCaArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-short-lived-certificate-c-as-delete-a-short-lived-certificate-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessShortLivedCertificateCAsDeleteAShortLivedCertificateCaArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-policies-list-access-app-policies_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesListAccessAppPoliciesArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-policies-create-an-access-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesCreateAnAccessPolicyArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppPolicyRequest,
}

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

/// Arguments for [`access-policies-update-an-access-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesUpdateAnAccessPolicyArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppPolicyRequest,
}

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

/// Arguments for [`access-policies-convert-reusable_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesConvertReusableArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-applications-revoke-service-tokens_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsRevokeServiceTokensArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-applications-put-update-access-application-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsPutUpdateAccessApplicationSettingsArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppSettingsRequest,
}

/// Arguments for [`access-applications-patch-update-access-application-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsPatchUpdateAccessApplicationSettingsArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessAppSettingsRequest,
}

/// Arguments for [`access-applications-test-access-policies_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessApplicationsTestAccessPoliciesArgs {
    /// Path parameter: `app_id`.
    pub app_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-mtls-authentication-list-mtls-certificates_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationListMtlsCertificatesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-mtls-authentication-add-an-mtls-certificate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationAddAnMtlsCertificateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessMtlsAuthenticationAddAnMtlsCertificateRequest,
}

/// Arguments for [`access-mtls-authentication-update-an-mtls-certificate-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationUpdateAnMtlsCertificateSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessMtlsAuthenticationUpdateAnMtlsCertificateSettingsRequest,
}

/// Arguments for [`access-mtls-authentication-get-an-mtls-certificate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationGetAnMtlsCertificateArgs {
    /// Path parameter: `certificate_id`.
    pub certificate_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-mtls-authentication-update-an-mtls-certificate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationUpdateAnMtlsCertificateArgs {
    /// Path parameter: `certificate_id`.
    pub certificate_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessMtlsAuthenticationUpdateAnMtlsCertificateRequest,
}

/// Arguments for [`access-mtls-authentication-delete-an-mtls-certificate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessMtlsAuthenticationDeleteAnMtlsCertificateArgs {
    /// Path parameter: `certificate_id`.
    pub certificate_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-gateway-ca-list-SSH-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGatewayCaListSSHCaArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-gateway-ca-add-an-SSH-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGatewayCaAddAnSSHCaArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-gateway-ca-delete-an-SSH-ca_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGatewayCaDeleteAnSSHCaArgs {
    /// Path parameter: `certificate_id`.
    pub certificate_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-groups-list-access-groups_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGroupsListAccessGroupsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-groups-create-an-access-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGroupsCreateAnAccessGroupArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessGroupsCreateAnAccessGroupRequest,
}

/// Arguments for [`access-groups-get-an-access-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGroupsGetAnAccessGroupArgs {
    /// Path parameter: `group_id`.
    pub group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-groups-update-an-access-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGroupsUpdateAnAccessGroupArgs {
    /// Path parameter: `group_id`.
    pub group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessGroupsUpdateAnAccessGroupRequest,
}

/// Arguments for [`access-groups-delete-an-access-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessGroupsDeleteAnAccessGroupArgs {
    /// Path parameter: `group_id`.
    pub group_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-identity-providers-list-access-identity-providers_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersListAccessIdentityProvidersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `scim_enabled`.
    pub scim_enabled: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-identity-providers-add-an-access-identity-provider_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersAddAnAccessIdentityProviderArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessIdentityProviders,
}

/// Arguments for [`access-identity-providers-get-an-access-identity-provider_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersGetAnAccessIdentityProviderArgs {
    /// Path parameter: `identity_provider_id`.
    pub identity_provider_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-identity-providers-update-an-access-identity-provider_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersUpdateAnAccessIdentityProviderArgs {
    /// Path parameter: `identity_provider_id`.
    pub identity_provider_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessIdentityProviders,
}

/// Arguments for [`access-identity-providers-delete-an-access-identity-provider_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersDeleteAnAccessIdentityProviderArgs {
    /// Path parameter: `identity_provider_id`.
    pub identity_provider_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-identity-providers-list-scim-group-resources_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersListScimGroupResourcesArgs {
    /// Path parameter: `identity_provider_id`.
    pub identity_provider_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `cf_resource_id`.
    pub cf_resource_id: Option<String>,
    /// Query parameter: `idp_resource_id`.
    pub idp_resource_id: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-identity-providers-list-scim-user-resources_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessIdentityProvidersListScimUserResourcesArgs {
    /// Path parameter: `identity_provider_id`.
    pub identity_provider_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `cf_resource_id`.
    pub cf_resource_id: Option<String>,
    /// Query parameter: `idp_resource_id`.
    pub idp_resource_id: Option<String>,
    /// Query parameter: `username`.
    pub username: Option<String>,
    /// Query parameter: `email`.
    pub email: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-key-configuration-get-the-access-key-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessKeyConfigurationGetTheAccessKeyConfigurationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-key-configuration-update-the-access-key-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessKeyConfigurationUpdateTheAccessKeyConfigurationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessKeyConfigurationUpdateTheAccessKeyConfigurationRequest,
}

/// Arguments for [`access-key-configuration-rotate-access-keys_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessKeyConfigurationRotateAccessKeysArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-authentication-logs-get-access-authentication-logs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessAuthenticationLogsGetAccessAuthenticationLogsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `until`.
    pub until: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `email`.
    pub email: Option<String>,
    /// Query parameter: `email_exact`.
    pub email_exact: Option<String>,
    /// Query parameter: `user_id`.
    pub user_id: Option<String>,
    /// Query parameter: `allowedOp`.
    pub allowed_op: Option<String>,
    /// Query parameter: `country_codeOp`.
    pub country_code_op: Option<String>,
    /// Query parameter: `app_typeOp`.
    pub app_type_op: Option<String>,
    /// Query parameter: `app_uidOp`.
    pub app_uid_op: Option<String>,
    /// Query parameter: `ray_idOp`.
    pub ray_id_op: Option<String>,
    /// Query parameter: `emailOp`.
    pub email_op: Option<String>,
    /// Query parameter: `idpOp`.
    pub idp_op: Option<String>,
    /// Query parameter: `non_identityOp`.
    pub non_identity_op: Option<String>,
    /// Query parameter: `user_idOp`.
    pub user_id_op: Option<String>,
    /// Query parameter: `fields`.
    pub fields: Option<String>,
}

/// Arguments for [`access-scim-update-logs-list-access-scim-update-logs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessScimUpdateLogsListAccessScimUpdateLogsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `until`.
    pub until: Option<String>,
    /// Query parameter: `idp_id`.
    pub idp_id: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `resource_type`.
    pub resource_type: Option<String>,
    /// Query parameter: `request_method`.
    pub request_method: Option<String>,
    /// Query parameter: `resource_user_email`.
    pub resource_user_email: Option<String>,
    /// Query parameter: `resource_group_name`.
    pub resource_group_name: Option<String>,
    /// Query parameter: `cf_resource_id`.
    pub cf_resource_id: Option<String>,
    /// Query parameter: `idp_resource_id`.
    pub idp_resource_id: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`zero-trust-organization-get-your-zero-trust-organization_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationGetYourZeroTrustOrganizationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-organization-create-your-zero-trust-organization_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationCreateYourZeroTrustOrganizationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustOrganizationCreateYourZeroTrustOrganizationRequest,
}

/// Arguments for [`zero-trust-organization-update-your-zero-trust-organization_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationUpdateYourZeroTrustOrganizationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustOrganizationUpdateYourZeroTrustOrganizationRequest,
}

/// Arguments for [`zero-trust-organization-get-your-zero-trust-organization-doh-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationGetYourZeroTrustOrganizationDohSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-organization-update-your-zero-trust-organization-doh-settings_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationUpdateYourZeroTrustOrganizationDohSettingsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustOrganizationUpdateYourZeroTrustOrganizationDohSettingsRequest,
}

/// Arguments for [`zero-trust-organization-revoke-all-access-tokens-for-a-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustOrganizationRevokeAllAccessTokensForAUserArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `devices`.
    pub devices: Option<String>,
    /// Request body.
    pub body: ZeroTrustOrganizationRevokeAllAccessTokensForAUserRequest,
}

/// Arguments for [`access-policies-list-access-reusable-policies_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesListAccessReusablePoliciesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-policies-create-an-access-reusable-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesCreateAnAccessReusablePolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessPolicyReq,
}

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

/// Arguments for [`access-policies-update-an-access-reusable-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPoliciesUpdateAnAccessReusablePolicyArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_id`.
    pub policy_id: String,
    /// Request body.
    pub body: AccessPolicyReq,
}

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

/// Arguments for [`access-policy-tests_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPolicyTestsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessPolicyInitReq,
}

/// Arguments for [`access-policy-tests-get-an-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPolicyTestsGetAnUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_test_id`.
    pub policy_test_id: String,
}

/// Arguments for [`access-policy-tests-get-a-user-page_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessPolicyTestsGetAUserPageArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `policy_test_id`.
    pub policy_test_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
}

/// Arguments for [`zero-trust-seats-update-a-user-seat_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustSeatsUpdateAUserSeatArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: Vec<AccessSeat>,
}

/// Arguments for [`access-service-tokens-list-service-tokens_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensListServiceTokensArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`access-service-tokens-create-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensCreateAServiceTokenArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessServiceTokensCreateAServiceTokenRequest,
}

/// Arguments for [`access-service-tokens-get-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensGetAServiceTokenArgs {
    /// Path parameter: `service_token_id`.
    pub service_token_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-service-tokens-update-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensUpdateAServiceTokenArgs {
    /// Path parameter: `service_token_id`.
    pub service_token_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessServiceTokensUpdateAServiceTokenRequest,
}

/// Arguments for [`access-service-tokens-delete-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensDeleteAServiceTokenArgs {
    /// Path parameter: `service_token_id`.
    pub service_token_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-service-tokens-refresh-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensRefreshAServiceTokenArgs {
    /// Path parameter: `service_token_id`.
    pub service_token_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`access-service-tokens-rotate-a-service-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessServiceTokensRotateAServiceTokenArgs {
    /// Path parameter: `service_token_id`.
    pub service_token_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessServiceTokensRotateAServiceTokenRequest,
}

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

/// Arguments for [`access-tags-create-tag_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessTagsCreateTagArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccessTagsCreateTagRequest,
}

/// Arguments for [`access-tags-get-a-tag_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessTagsGetATagArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `tag_name`.
    pub tag_name: String,
}

/// Arguments for [`access-tags-update-a-tag_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessTagsUpdateATagArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `tag_name`.
    pub tag_name: String,
    /// Request body.
    pub body: AccessTagWithoutAppCount,
}

/// Arguments for [`access-tags-delete-a-tag_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccessTagsDeleteATagArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `tag_name`.
    pub tag_name: String,
}

/// Arguments for [`zero-trust-users-get-users_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetUsersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `email`.
    pub email: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`zero-trust-users-create-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersCreateUserArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustUsersCreateUserRequest,
}

/// Arguments for [`zero-trust-users-get-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetUserArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-users-update-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersUpdateUserArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: ZeroTrustUsersUpdateUserRequest,
}

/// Arguments for [`zero-trust-users-delete-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersDeleteUserArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-users-get-active-sessions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetActiveSessionsArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-users-get-active-session_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetActiveSessionArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `nonce`.
    pub nonce: String,
}

/// Arguments for [`zero-trust-users-get-failed-logins_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetFailedLoginsArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-users-get-last-seen-identity_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersGetLastSeenIdentityArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`zero-trust-users-delete-mfa-authenticator_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ZeroTrustUsersDeleteMfaAuthenticatorArgs {
    /// Path parameter: `user_id`.
    pub user_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `authenticator_id`.
    pub authenticator_id: String,
}

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

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

/// Arguments for [`account-permission-group-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountPermissionGroupListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `label`.
    pub label: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`account-permission-group-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountPermissionGroupDetailsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `permission_group_id`.
    pub permission_group_id: String,
}

/// Arguments for [`account-resource-group-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountResourceGroupListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
}

/// Arguments for [`account-resource-group-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountResourceGroupCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IamRequestCreateResourceGroup,
}

/// Arguments for [`account-resource-group-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountResourceGroupDetailsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `resource_group_id`.
    pub resource_group_id: String,
}

/// Arguments for [`account-resource-group-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountResourceGroupUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `resource_group_id`.
    pub resource_group_id: String,
    /// Request body.
    pub body: IamRequestUpdateResourceGroup,
}

/// Arguments for [`account-resource-group-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountResourceGroupDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `resource_group_id`.
    pub resource_group_id: String,
}

/// Arguments for [`account-user-group-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `fuzzyName`.
    pub fuzzy_name: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

/// Arguments for [`account-user-group-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: IamCreateUserGroupBody,
}

/// Arguments for [`account-user-group-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupDetailsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
}

/// Arguments for [`account-user-group-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
    /// Request body.
    pub body: IamUpdateUserGroupBody,
}

/// Arguments for [`account-user-group-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
}

/// Arguments for [`account-user-group-member-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupMemberListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`account-user-group-member-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupMemberCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
    /// Request body.
    pub body: Vec<AccountUserGroupMemberCreateRequestItem>,
}

/// Arguments for [`account-user-group-members-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupMembersUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
    /// Request body.
    pub body: Vec<AccountUserGroupMembersUpdateRequestItem>,
}

/// Arguments for [`account-user-group-member-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountUserGroupMemberDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_group_id`.
    pub user_group_id: String,
    /// Path parameter: `member_id`.
    pub member_id: String,
}

/// Arguments for [`account-members-list-members_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountMembersListMembersArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

/// Arguments for [`account-members-add-member_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountMembersAddMemberArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountMembersAddMemberRequest,
}

/// Arguments for [`account-members-member-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountMembersMemberDetailsArgs {
    /// Path parameter: `member_id`.
    pub member_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`account-members-update-member_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountMembersUpdateMemberArgs {
    /// Path parameter: `member_id`.
    pub member_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: AccountMembersUpdateMemberRequest,
}

/// Arguments for [`account-members-remove-member_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountMembersRemoveMemberArgs {
    /// Path parameter: `member_id`.
    pub member_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

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

/// Arguments for [`account-roles-role-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AccountRolesRoleDetailsArgs {
    /// Path parameter: `role_id`.
    pub role_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`scim-groups-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimGroupsListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `startIndex`.
    pub start_index: Option<String>,
    /// Query parameter: `count`.
    pub count: Option<String>,
    /// Query parameter: `filter`.
    pub filter: Option<String>,
}

/// Arguments for [`scim-groups-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimGroupsCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`scim-groups-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimGroupsGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `group_id`.
    pub group_id: String,
}

/// Arguments for [`scim-groups-patch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimGroupsPatchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `group_id`.
    pub group_id: String,
}

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

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

/// Arguments for [`scim-resource-types-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimResourceTypesGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `resource_type_id`.
    pub resource_type_id: String,
}

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

/// Arguments for [`scim-schemas-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimSchemasGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `schema_id`.
    pub schema_id: String,
}

/// Arguments for [`scim-service-provider-config-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimServiceProviderConfigGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`scim-users-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimUsersListArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `startIndex`.
    pub start_index: Option<String>,
    /// Query parameter: `count`.
    pub count: Option<String>,
    /// Query parameter: `filter`.
    pub filter: Option<String>,
}

/// Arguments for [`scim-users-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimUsersCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`scim-users-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimUsersGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_id`.
    pub user_id: String,
}

/// Arguments for [`scim-users-put_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimUsersPutArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_id`.
    pub user_id: String,
}

/// Arguments for [`scim-users-patch_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ScimUsersPatchArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_id`.
    pub user_id: String,
}

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

/// Arguments for [`init-new-sso-connector_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct InitNewSsoConnectorArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: InitNewSsoConnectorRequest,
}

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

/// Arguments for [`update-sso-connector-state_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateSsoConnectorStateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `sso_connector_id`.
    pub sso_connector_id: String,
    /// Request body.
    pub body: UpdateSsoConnectorStateRequest,
}

/// Arguments for [`delete-sso-connector_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteSsoConnectorArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `sso_connector_id`.
    pub sso_connector_id: String,
}

/// Arguments for [`begin-sso-connector-verification_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct BeginSsoConnectorVerificationArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `sso_connector_id`.
    pub sso_connector_id: String,
}

/// Arguments for [`dlp-risk-score-summary-get-for-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpRiskScoreSummaryGetForUserArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_id`.
    pub user_id: String,
}

/// Arguments for [`dlp-risk-score-reset-post_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpRiskScoreResetPostArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `user_id`.
    pub user_id: String,
}

/// Arguments for [`user'-s-account-memberships-list-memberships_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSAccountMembershipsListMembershipsArgs {
    /// Query parameter: `account.name`.
    pub account_name: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
}

/// Arguments for [`user'-s-account-memberships-membership-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSAccountMembershipsMembershipDetailsArgs {
    /// Path parameter: `membership_id`.
    pub membership_id: String,
}

/// Arguments for [`user'-s-account-memberships-update-membership_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSAccountMembershipsUpdateMembershipArgs {
    /// Path parameter: `membership_id`.
    pub membership_id: String,
    /// Request body.
    pub body: UserSAccountMembershipsUpdateMembershipRequest,
}

/// Arguments for [`user'-s-account-memberships-delete-membership_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSAccountMembershipsDeleteMembershipArgs {
    /// Path parameter: `membership_id`.
    pub membership_id: String,
}

/// Arguments for [`Organization_listOrganizations_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationListOrganizationsArgs {
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `name.startsWith`.
    pub name_starts_with: Option<String>,
    /// Query parameter: `name.endsWith`.
    pub name_ends_with: Option<String>,
    /// Query parameter: `name.contains`.
    pub name_contains: Option<String>,
    /// Query parameter: `containing.account`.
    pub containing_account: Option<String>,
    /// Query parameter: `containing.user`.
    pub containing_user: Option<String>,
    /// Query parameter: `containing.organization`.
    pub containing_organization: Option<String>,
    /// Query parameter: `parent.id`.
    pub parent_id: Option<String>,
    /// Query parameter: `page_token`.
    pub page_token: Option<String>,
    /// Query parameter: `page_size`.
    pub page_size: Option<String>,
}

/// Arguments for [`Organizations_createUserOrganization_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationsCreateUserOrganizationArgs {
    /// Request body.
    pub body: OrganizationsApiOrganization,
}

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

/// Arguments for [`Organizations_modify_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationsModifyArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Request body.
    pub body: OrganizationsApiOrganization,
}

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

/// Arguments for [`Organizations_getAccounts_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationsGetAccountsArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Query parameter: `account_pubname`.
    pub account_pubname: Option<String>,
    /// Query parameter: `account_pubname.startsWith`.
    pub account_pubname_starts_with: Option<String>,
    /// Query parameter: `account_pubname.endsWith`.
    pub account_pubname_ends_with: Option<String>,
    /// Query parameter: `account_pubname.contains`.
    pub account_pubname_contains: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `name.startsWith`.
    pub name_starts_with: Option<String>,
    /// Query parameter: `name.endsWith`.
    pub name_ends_with: Option<String>,
    /// Query parameter: `name.contains`.
    pub name_contains: Option<String>,
    /// Query parameter: `order_by`.
    pub order_by: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `page_token`.
    pub page_token: Option<String>,
    /// Query parameter: `page_size`.
    pub page_size: Option<String>,
}

/// Arguments for [`audit-logs-v2-get-organization-audit-logs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AuditLogsV2GetOrganizationAuditLogsArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Query parameter: `action_result`.
    pub action_result: Option<String>,
    /// Query parameter: `action_type`.
    pub action_type: Option<String>,
    /// Query parameter: `actor_context`.
    pub actor_context: Option<String>,
    /// Query parameter: `actor_email`.
    pub actor_email: Option<String>,
    /// Query parameter: `actor_id`.
    pub actor_id: Option<String>,
    /// Query parameter: `actor_ip_address`.
    pub actor_ip_address: Option<String>,
    /// Query parameter: `actor_token_id`.
    pub actor_token_id: Option<String>,
    /// Query parameter: `actor_token_name`.
    pub actor_token_name: Option<String>,
    /// Query parameter: `actor_type`.
    pub actor_type: Option<String>,
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `raw_cf_ray_id`.
    pub raw_cf_ray_id: Option<String>,
    /// Query parameter: `raw_method`.
    pub raw_method: Option<String>,
    /// Query parameter: `raw_status_code`.
    pub raw_status_code: Option<String>,
    /// Query parameter: `raw_uri`.
    pub raw_uri: Option<String>,
    /// Query parameter: `resource_id`.
    pub resource_id: Option<String>,
    /// Query parameter: `resource_product`.
    pub resource_product: Option<String>,
    /// Query parameter: `resource_type`.
    pub resource_type: Option<String>,
    /// Query parameter: `resource_scope`.
    pub resource_scope: Option<String>,
    /// Query parameter: `action_result.not`.
    pub action_result_not: Option<String>,
    /// Query parameter: `action_type.not`.
    pub action_type_not: Option<String>,
    /// Query parameter: `actor_context.not`.
    pub actor_context_not: Option<String>,
    /// Query parameter: `actor_email.not`.
    pub actor_email_not: Option<String>,
    /// Query parameter: `actor_id.not`.
    pub actor_id_not: Option<String>,
    /// Query parameter: `actor_ip_address.not`.
    pub actor_ip_address_not: Option<String>,
    /// Query parameter: `actor_token_id.not`.
    pub actor_token_id_not: Option<String>,
    /// Query parameter: `actor_token_name.not`.
    pub actor_token_name_not: Option<String>,
    /// Query parameter: `actor_type.not`.
    pub actor_type_not: Option<String>,
    /// Query parameter: `id.not`.
    pub id_not: Option<String>,
    /// Query parameter: `raw_cf_ray_id.not`.
    pub raw_cf_ray_id_not: Option<String>,
    /// Query parameter: `raw_method.not`.
    pub raw_method_not: Option<String>,
    /// Query parameter: `raw_status_code.not`.
    pub raw_status_code_not: Option<String>,
    /// Query parameter: `raw_uri.not`.
    pub raw_uri_not: Option<String>,
    /// Query parameter: `resource_id.not`.
    pub resource_id_not: Option<String>,
    /// Query parameter: `resource_product.not`.
    pub resource_product_not: Option<String>,
    /// Query parameter: `resource_type.not`.
    pub resource_type_not: Option<String>,
    /// Query parameter: `resource_scope.not`.
    pub resource_scope_not: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `before`.
    pub before: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
}

/// Arguments for [`Members_list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MembersListArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `user.email`.
    pub user_email: Option<String>,
    /// Query parameter: `user.email.contains`.
    pub user_email_contains: Option<String>,
    /// Query parameter: `user.email.startsWith`.
    pub user_email_starts_with: Option<String>,
    /// Query parameter: `user.email.endsWith`.
    pub user_email_ends_with: Option<String>,
    /// Query parameter: `page_token`.
    pub page_token: Option<String>,
    /// Query parameter: `page_size`.
    pub page_size: Option<String>,
}

/// Arguments for [`Members_create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MembersCreateArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Request body.
    pub body: OrganizationsApiCreateMemberRequest,
}

/// Arguments for [`Members_retrieve_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MembersRetrieveArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Path parameter: `member_id`.
    pub member_id: String,
}

/// Arguments for [`Members_delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MembersDeleteArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Path parameter: `member_id`.
    pub member_id: String,
    /// Request body.
    pub body: MembersDeleteRequest,
}

/// Arguments for [`Members_batchCreate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MembersBatchCreateArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Request body.
    pub body: OrganizationsApiBatchCreateMembersRequest,
}

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

/// Arguments for [`Organizations_modifyProfile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationsModifyProfileArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Request body.
    pub body: OrganizationsApiProfile,
}

/// Arguments for [`organization-shares-list_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct OrganizationSharesListArgs {
    /// Path parameter: `organization_id`.
    pub organization_id: String,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `kind`.
    pub kind: Option<String>,
    /// Query parameter: `target_type`.
    pub target_type: Option<String>,
    /// Query parameter: `resource_types`.
    pub resource_types: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

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

/// Arguments for [`user-user-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserUserDetailsArgs {
}

/// Arguments for [`user-edit-user_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserEditUserArgs {
    /// Request body.
    pub body: UserEditUserRequest,
}

/// Arguments for [`audit-logs-get-user-audit-logs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AuditLogsGetUserAuditLogsArgs {
    /// Query parameter: `id`.
    pub id: Option<String>,
    /// Query parameter: `export`.
    pub export: Option<String>,
    /// Query parameter: `action.type`.
    pub action_type: Option<String>,
    /// Query parameter: `actor.ip`.
    pub actor_ip: Option<String>,
    /// Query parameter: `actor.email`.
    pub actor_email: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `before`.
    pub before: Option<String>,
    /// Query parameter: `zone.name`.
    pub zone_name: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `hide_user_logs`.
    pub hide_user_logs: Option<String>,
}

/// Arguments for [`user'-s-invites-list-invitations_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSInvitesListInvitationsArgs {
}

/// Arguments for [`user'-s-invites-invitation-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSInvitesInvitationDetailsArgs {
    /// Path parameter: `invite_id`.
    pub invite_id: String,
}

/// Arguments for [`user'-s-invites-respond-to-invitation_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSInvitesRespondToInvitationArgs {
    /// Path parameter: `invite_id`.
    pub invite_id: String,
    /// Request body.
    pub body: UserSInvitesRespondToInvitationRequest,
}

/// Arguments for [`load-balancer-monitors-list-monitors_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerMonitorsListMonitorsArgs {
}

/// Arguments for [`load-balancer-monitors-create-monitor_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerMonitorsCreateMonitorArgs {
    /// Request body.
    pub body: LoadBalancerMonitorsCreateMonitorRequest,
}

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

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

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

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

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

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

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

/// Arguments for [`load-balancer-pools-create-pool_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerPoolsCreatePoolArgs {
    /// Request body.
    pub body: LoadBalancerPoolsCreatePoolRequest,
}

/// Arguments for [`load-balancer-pools-patch-pools_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerPoolsPatchPoolsArgs {
    /// Request body.
    pub body: LoadBalancerPoolsPatchPoolsRequest,
}

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

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

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

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

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

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

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

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

/// Arguments for [`load-balancer-healthcheck-events-list-healthcheck-events_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct LoadBalancerHealthcheckEventsListHealthcheckEventsArgs {
    /// Query parameter: `until`.
    pub until: Option<String>,
    /// Query parameter: `pool_name`.
    pub pool_name: Option<String>,
    /// Query parameter: `origin_healthy`.
    pub origin_healthy: Option<String>,
    /// Query parameter: `pool_id`.
    pub pool_id: Option<String>,
    /// Query parameter: `since`.
    pub since: Option<String>,
    /// Query parameter: `origin_name`.
    pub origin_name: Option<String>,
    /// Query parameter: `pool_healthy`.
    pub pool_healthy: Option<String>,
}

/// Arguments for [`user-subscription-get-user-subscriptions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSubscriptionGetUserSubscriptionsArgs {
}

/// Arguments for [`user-subscription-update-user-subscription_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSubscriptionUpdateUserSubscriptionArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Request body.
    pub body: BillSubsApiSubscriptionV2,
}

/// Arguments for [`user-subscription-delete-user-subscription_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserSubscriptionDeleteUserSubscriptionArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
}

/// Arguments for [`user-api-tokens-list-tokens_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensListTokensArgs {
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

/// Arguments for [`user-api-tokens-create-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensCreateTokenArgs {
    /// Request body.
    pub body: IamCreatePayload,
}

/// Arguments for [`permission-groups-list-permission-groups_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct PermissionGroupsListPermissionGroupsArgs {
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `scope`.
    pub scope: Option<String>,
}

/// Arguments for [`user-api-tokens-verify-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensVerifyTokenArgs {
}

/// Arguments for [`user-api-tokens-token-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensTokenDetailsArgs {
    /// Path parameter: `token_id`.
    pub token_id: String,
}

/// Arguments for [`user-api-tokens-update-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensUpdateTokenArgs {
    /// Path parameter: `token_id`.
    pub token_id: String,
    /// Request body.
    pub body: IamTokenBody,
}

/// Arguments for [`user-api-tokens-delete-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensDeleteTokenArgs {
    /// Path parameter: `token_id`.
    pub token_id: String,
}

/// Arguments for [`user-api-tokens-roll-token_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserApiTokensRollTokenArgs {
    /// Path parameter: `token_id`.
    pub token_id: String,
}

/// Arguments for [`User_listUserTenants_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UserListUserTenantsArgs {
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/abuse-reports
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("sort", args.sort.as_deref());
    builder = builder.query("domain", args.domain.as_deref());
    builder = builder.query("created_before", args.created_before.as_deref());
    builder = builder.query("created_after", args.created_after.as_deref());
    builder = builder.query("status", args.status.as_deref());
    builder = builder.query("type", args.r#type.as_deref());
    builder = builder.query("mitigation_status", args.mitigation_status.as_deref());

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: ListAbuseReportsResponse = serde_json::from_slice(&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}/abuse-reports/{report_param}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: McpPortalsApiListPortalsResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/portals
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/access/ai-controls/mcp/portals/{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 = mcp_portals_api_fetch_gateways_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_fetch_gateways_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiFetchGatewaysArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiFetchGatewaysResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/portals/{}",
        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: McpPortalsApiFetchGatewaysResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/portals/{id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/access/ai-controls/mcp/portals/{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 = mcp_portals_api_update_portals_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_update_portals_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiUpdatePortalsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiUpdatePortalsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/portals/{}",
        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: McpPortalsApiUpdatePortalsResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/portals/{id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/access/ai-controls/mcp/portals/{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 = mcp_portals_api_delete_portals_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_delete_portals_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiDeletePortalsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiDeletePortalsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/portals/{}",
        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: McpPortalsApiDeletePortalsResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/servers
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: McpPortalsApiListServersResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/servers
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/access/ai-controls/mcp/servers/{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 = mcp_portals_api_fetch_servers_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_fetch_servers_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiFetchServersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiFetchServersResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/servers/{}",
        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: McpPortalsApiFetchServersResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/servers/{id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/access/ai-controls/mcp/servers/{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 = mcp_portals_api_update_servers_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_update_servers_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiUpdateServersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiUpdateServersResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/servers/{}",
        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: McpPortalsApiUpdateServersResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/servers/{id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/access/ai-controls/mcp/servers/{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 = mcp_portals_api_delete_servers_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn mcp_portals_api_delete_servers_request<F>(
    client: DynNetClient,
    args: &McpPortalsApiDeleteServersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<McpPortalsApiDeleteServersResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/ai-controls/mcp/servers/{}",
        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: McpPortalsApiDeleteServersResponse = serde_json::from_slice(&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}/access/ai-controls/mcp/servers/{id}/sync
// -----------------------------------------------------------------------------

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

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

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

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("domain", args.domain.as_deref());
    builder = builder.query("aud", args.aud.as_deref());
    builder = builder.query("target_attributes", args.target_attributes.as_deref());
    builder = builder.query("exact", args.exact.as_deref());
    builder = builder.query("search", args.search.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: AccessAppsComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/apps
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessApplicationsAddAnApplicationResponse = serde_json::from_slice(&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}/access/apps/ca
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessCaComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/apps/{app_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessApplicationsUpdateAnAccessApplicationResponse = serde_json::from_slice(&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}/access/apps/{app_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessIdResponse = serde_json::from_slice(&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}/access/apps/{app_id}/ca
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessSchemasIdResponse = serde_json::from_slice(&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}/access/apps/{app_id}/policies
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessAppPoliciesComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/apps/{app_id}/policies
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessAppPoliciesComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/apps/{app_id}/policies/{policy_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessAppPoliciesComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/apps/{app_id}/policies/{policy_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessAppPoliciesComponentsSchemasIdResponse = serde_json::from_slice(&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}/access/apps/{app_id}/policies/{policy_id}/make_reusable
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessAppPoliciesComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/apps/{app_id}/revoke_tokens
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessApplicationsPutUpdateAccessApplicationSettingsResponse = serde_json::from_slice(&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}/access/apps/{app_id}/settings
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessApplicationsPatchUpdateAccessApplicationSettingsResponse = serde_json::from_slice(&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}/access/apps/{app_id}/user_policy_checks
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessCertificatesComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/certificates
// -----------------------------------------------------------------------------

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

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

    let mut builder = PreparedRequestBuilder::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: AccessResponseCollectionHostnames = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

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

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

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

/// DELETE /accounts/{account_id}/access/certificates/{certificate_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 = access_mtls_authentication_delete_an_mtls_certificate_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_mtls_authentication_delete_an_mtls_certificate_request<F>(
    client: DynNetClient,
    args: &AccessMtlsAuthenticationDeleteAnMtlsCertificateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessComponentsSchemasIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/certificates/{}",
        args.account_id,
        args.certificate_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: AccessComponentsSchemasIdResponse = serde_json::from_slice(&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}/access/gateway_ca
// -----------------------------------------------------------------------------

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

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

/// DELETE /accounts/{account_id}/access/gateway_ca/{certificate_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 = access_gateway_ca_delete_an_ssh_ca_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_gateway_ca_delete_an_ssh_ca_request<F>(
    client: DynNetClient,
    args: &AccessGatewayCaDeleteAnSSHCaArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/gateway_ca/{}",
        args.account_id,
        args.certificate_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: AccessIdResponse = serde_json::from_slice(&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}/access/groups
// -----------------------------------------------------------------------------

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

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("search", args.search.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: AccessSchemasResponseCollection = serde_json::from_slice(&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}/access/groups
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    builder = builder.query("scim_enabled", args.scim_enabled.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: AccessResponseCollection = serde_json::from_slice(&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}/access/identity_providers
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/identity_providers/{identity_provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/identity_providers/{identity_provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/identity_providers/{identity_provider_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessIdResponse = serde_json::from_slice(&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}/access/identity_providers/{identity_provider_id}/scim/groups
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("cf_resource_id", args.cf_resource_id.as_deref());
    builder = builder.query("idp_resource_id", args.idp_resource_id.as_deref());
    builder = builder.query("name", args.name.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: AccessScimGroupsResponse = serde_json::from_slice(&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}/access/identity_providers/{identity_provider_id}/scim/users
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("cf_resource_id", args.cf_resource_id.as_deref());
    builder = builder.query("idp_resource_id", args.idp_resource_id.as_deref());
    builder = builder.query("username", args.username.as_deref());
    builder = builder.query("email", args.email.as_deref());
    builder = builder.query("name", args.name.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: AccessScimUsersResponse = serde_json::from_slice(&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}/access/keys
// -----------------------------------------------------------------------------

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

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

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

/// GET /accounts/{account_id}/access/logs/access_requests.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = access_authentication_logs_get_access_authentication_logs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_authentication_logs_get_access_authentication_logs_request<F>(
    client: DynNetClient,
    args: &AccessAuthenticationLogsGetAccessAuthenticationLogsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessAccessRequestsComponentsSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/logs/access_requests",
        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("limit", args.limit.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("until", args.until.as_deref());
    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("email", args.email.as_deref());
    builder = builder.query("email_exact", args.email_exact.as_deref());
    builder = builder.query("user_id", args.user_id.as_deref());
    builder = builder.query("allowedOp", args.allowed_op.as_deref());
    builder = builder.query("country_codeOp", args.country_code_op.as_deref());
    builder = builder.query("app_typeOp", args.app_type_op.as_deref());
    builder = builder.query("app_uidOp", args.app_uid_op.as_deref());
    builder = builder.query("ray_idOp", args.ray_id_op.as_deref());
    builder = builder.query("emailOp", args.email_op.as_deref());
    builder = builder.query("idpOp", args.idp_op.as_deref());
    builder = builder.query("non_identityOp", args.non_identity_op.as_deref());
    builder = builder.query("user_idOp", args.user_id_op.as_deref());
    builder = builder.query("fields", args.fields.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: AccessAccessRequestsComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/logs/scim/updates
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/access/logs/scim/updates.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = access_scim_update_logs_list_access_scim_update_logs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_scim_update_logs_list_access_scim_update_logs_request<F>(
    client: DynNetClient,
    args: &AccessScimUpdateLogsListAccessScimUpdateLogsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessScimUpdateLogsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/logs/scim/updates",
        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("limit", args.limit.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("until", args.until.as_deref());
    builder = builder.query("idp_id", args.idp_id.as_deref());
    builder = builder.query("status", args.status.as_deref());
    builder = builder.query("resource_type", args.resource_type.as_deref());
    builder = builder.query("request_method", args.request_method.as_deref());
    builder = builder.query("resource_user_email", args.resource_user_email.as_deref());
    builder = builder.query("resource_group_name", args.resource_group_name.as_deref());
    builder = builder.query("cf_resource_id", args.cf_resource_id.as_deref());
    builder = builder.query("idp_resource_id", args.idp_resource_id.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: AccessScimUpdateLogsResponse = serde_json::from_slice(&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}/access/organizations
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    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: AccessEmptyResponse = serde_json::from_slice(&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}/access/policies
// -----------------------------------------------------------------------------

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

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

    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: AccessReusablePoliciesComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/policies
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessReusablePoliciesComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/policies/{policy_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessReusablePoliciesComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/policies/{policy_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessReusablePoliciesComponentsSchemasSingleResponse = serde_json::from_slice(&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}/access/policies/{policy_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessReusablePoliciesComponentsSchemasIdResponse = serde_json::from_slice(&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}/access/policy-tests
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/access/policy-tests/{policy_test_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 = access_policy_tests_get_an_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_policy_tests_get_an_update_request<F>(
    client: DynNetClient,
    args: &AccessPolicyTestsGetAnUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessPolicyUpdateResp>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/policy-tests/{}",
        args.account_id,
        args.policy_test_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: AccessPolicyUpdateResp = serde_json::from_slice(&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}/access/policy-tests/{policy_test_id}/users
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessPolicyUsersResp = serde_json::from_slice(&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}/access/seats
// -----------------------------------------------------------------------------

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

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

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

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("search", args.search.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: AccessComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/service_tokens
// -----------------------------------------------------------------------------

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

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

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

/// DELETE /accounts/{account_id}/access/service_tokens/{service_token_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 = access_service_tokens_delete_a_service_token_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn access_service_tokens_delete_a_service_token_request<F>(
    client: DynNetClient,
    args: &AccessServiceTokensDeleteAServiceTokenArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/service_tokens/{}",
        args.account_id,
        args.service_token_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: AccessSchemasSingleResponse = serde_json::from_slice(&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}/access/service_tokens/{service_token_id}/refresh
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccessTagsComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/tags
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("email", args.email.as_deref());
    builder = builder.query("search", args.search.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: AccessUsersComponentsSchemasResponseCollection = serde_json::from_slice(&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}/access/users
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

/// DELETE /accounts/{account_id}/access/users/{user_id}/mfa_authenticators/{authenticator_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = zero_trust_users_delete_mfa_authenticator_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn zero_trust_users_delete_mfa_authenticator_request<F>(
    client: DynNetClient,
    args: &ZeroTrustUsersDeleteMfaAuthenticatorArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccessDeleteAuthenticatorResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/access/users/{}/mfa_authenticators/{}",
        args.account_id,
        args.user_id,
        args.authenticator_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: AccessDeleteAuthenticatorResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

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

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/iam/permission_groups
// -----------------------------------------------------------------------------

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

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("label", args.label.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: IamCollectionPermissionGroupsResponse = serde_json::from_slice(&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}/iam/permission_groups/{permission_group_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/iam/permission_groups/{permission_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_permission_group_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_permission_group_details_request<F>(
    client: DynNetClient,
    args: &AccountPermissionGroupDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSinglePermissionGroupsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/permission_groups/{}",
        args.account_id,
        args.permission_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: IamSinglePermissionGroupsResponse = serde_json::from_slice(&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}/iam/resource_groups
// -----------------------------------------------------------------------------

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

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("name", args.name.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: AccountResourceGroupListResponse = serde_json::from_slice(&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}/iam/resource_groups
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/iam/resource_groups/{resource_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_resource_group_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_resource_group_details_request<F>(
    client: DynNetClient,
    args: &AccountResourceGroupDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountResourceGroupDetailsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/resource_groups/{}",
        args.account_id,
        args.resource_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: AccountResourceGroupDetailsResponse = serde_json::from_slice(&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}/iam/resource_groups/{resource_group_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/iam/resource_groups/{resource_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_resource_group_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_resource_group_update_request<F>(
    client: DynNetClient,
    args: &AccountResourceGroupUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountResourceGroupUpdateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/resource_groups/{}",
        args.account_id,
        args.resource_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: AccountResourceGroupUpdateResponse = serde_json::from_slice(&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}/iam/resource_groups/{resource_group_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/iam/resource_groups/{resource_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_resource_group_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_resource_group_delete_request<F>(
    client: DynNetClient,
    args: &AccountResourceGroupDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamApiResponseSingleId>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/resource_groups/{}",
        args.account_id,
        args.resource_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: IamApiResponseSingleId = serde_json::from_slice(&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}/iam/user_groups
// -----------------------------------------------------------------------------

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

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("fuzzyName", args.fuzzy_name.as_deref());
    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("direction", args.direction.as_deref());

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AccountUserGroupListResponse = serde_json::from_slice(&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}/iam/user_groups
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/iam/user_groups/{user_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_user_group_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_details_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupDetailsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}",
        args.account_id,
        args.user_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: AccountUserGroupDetailsResponse = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/iam/user_groups/{user_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_user_group_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_update_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupUpdateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}",
        args.account_id,
        args.user_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: AccountUserGroupUpdateResponse = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/iam/user_groups/{user_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_user_group_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_delete_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamApiResponseSingleId>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}",
        args.account_id,
        args.user_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: IamApiResponseSingleId = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}/members
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/iam/user_groups/{user_group_id}/members.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_user_group_member_list_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_member_list_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupMemberListArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupMemberListResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}/members",
        args.account_id,
        args.user_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()))?;

    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: AccountUserGroupMemberListResponse = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}/members
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/iam/user_groups/{user_group_id}/members.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_user_group_member_create_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_member_create_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupMemberCreateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupMemberCreateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}/members",
        args.account_id,
        args.user_group_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: AccountUserGroupMemberCreateResponse = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}/members
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/iam/user_groups/{user_group_id}/members.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_user_group_members_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_members_update_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupMembersUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupMembersUpdateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}/members",
        args.account_id,
        args.user_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: AccountUserGroupMembersUpdateResponse = serde_json::from_slice(&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}/iam/user_groups/{user_group_id}/members/{member_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/iam/user_groups/{user_group_id}/members/{member_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_user_group_member_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_user_group_member_delete_request<F>(
    client: DynNetClient,
    args: &AccountUserGroupMemberDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AccountUserGroupMemberDeleteResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/iam/user_groups/{}/members/{}",
        args.account_id,
        args.user_group_id,
        args.member_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: AccountUserGroupMemberDeleteResponse = serde_json::from_slice(&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}/members
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/members.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_members_list_members_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_members_list_members_request<F>(
    client: DynNetClient,
    args: &AccountMembersListMembersArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamCollectionMemberResponseWithPolicies>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/members",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamCollectionMemberResponseWithPolicies = serde_json::from_slice(&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}/members
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/members.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_members_add_member_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_members_add_member_request<F>(
    client: DynNetClient,
    args: &AccountMembersAddMemberArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleMemberResponseWithPolicies>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/members",
        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: IamSingleMemberResponseWithPolicies = serde_json::from_slice(&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}/members/{member_id}
// -----------------------------------------------------------------------------

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

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

/// DELETE /accounts/{account_id}/members/{member_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_members_remove_member_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_members_remove_member_request<F>(
    client: DynNetClient,
    args: &AccountMembersRemoveMemberArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamApiResponseSingleId>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/members/{}",
        args.account_id,
        args.member_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: IamApiResponseSingleId = serde_json::from_slice(&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}/organizations
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/roles.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_roles_list_roles_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_roles_list_roles_request<F>(
    client: DynNetClient,
    args: &AccountRolesListRolesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamCollectionRoleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/roles",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamCollectionRoleResponse = serde_json::from_slice(&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}/roles/{role_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/roles/{role_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_roles_role_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn account_roles_role_details_request<F>(
    client: DynNetClient,
    args: &AccountRolesRoleDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleRoleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/roles/{}",
        args.account_id,
        args.role_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: IamSingleRoleResponse = serde_json::from_slice(&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}/scim/v2/Groups
// -----------------------------------------------------------------------------

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

    builder = builder.query("startIndex", args.start_index.as_deref());
    builder = builder.query("count", args.count.as_deref());
    builder = builder.query("filter", args.filter.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 });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/scim/v2/Groups
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/Groups/{group_id}
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/scim/v2/Groups/{group_id}
// -----------------------------------------------------------------------------

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

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

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

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

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/scim/v2/Groups/{group_id}
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/ResourceTypes
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/ResourceTypes/{resource_type_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/Schemas
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/Schemas/{schema_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/ServiceProviderConfig
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/Users
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/scim/v2/Users
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/scim/v2/Users/{user_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/scim/v2/Users/{user_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/scim/v2/Users/{user_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/sso_connectors
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamSsoConnectorCollectionResponse = serde_json::from_slice(&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}/sso_connectors
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamSsoConnectorResponse = serde_json::from_slice(&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}/sso_connectors/{sso_connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamSsoConnectorResponse = serde_json::from_slice(&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}/sso_connectors/{sso_connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamSsoConnectorResponse = serde_json::from_slice(&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}/sso_connectors/{sso_connector_id}
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamApiResponseSingleId = serde_json::from_slice(&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}/sso_connectors/{sso_connector_id}/begin_verification
// -----------------------------------------------------------------------------

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: UserSAccountMembershipsListMembershipsResponse = serde_json::from_slice(&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 /memberships/{membership_id}
// -----------------------------------------------------------------------------

/// GET /memberships/{membership_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 = user_s_account_memberships_membership_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_s_account_memberships_membership_details_request<F>(
    client: DynNetClient,
    args: &UserSAccountMembershipsMembershipDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleMembershipResponseWithPolicies>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/memberships/{}",
        args.membership_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: IamSingleMembershipResponseWithPolicies = serde_json::from_slice(&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 /memberships/{membership_id}
// -----------------------------------------------------------------------------

/// PUT /memberships/{membership_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 = user_s_account_memberships_update_membership_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_s_account_memberships_update_membership_request<F>(
    client: DynNetClient,
    args: &UserSAccountMembershipsUpdateMembershipArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleMembershipResponseWithPolicies>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/memberships/{}",
        args.membership_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: IamSingleMembershipResponseWithPolicies = serde_json::from_slice(&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 /memberships/{membership_id}
// -----------------------------------------------------------------------------

/// DELETE /memberships/{membership_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 = user_s_account_memberships_delete_membership_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_s_account_memberships_delete_membership_request<F>(
    client: DynNetClient,
    args: &UserSAccountMembershipsDeleteMembershipArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<UserSAccountMembershipsDeleteMembershipResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/memberships/{}",
        args.membership_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: UserSAccountMembershipsDeleteMembershipResponse = serde_json::from_slice(&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 /organizations
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("name.startsWith", args.name_starts_with.as_deref());
    builder = builder.query("name.endsWith", args.name_ends_with.as_deref());
    builder = builder.query("name.contains", args.name_contains.as_deref());
    builder = builder.query("containing.account", args.containing_account.as_deref());
    builder = builder.query("containing.user", args.containing_user.as_deref());
    builder = builder.query("containing.organization", args.containing_organization.as_deref());
    builder = builder.query("parent.id", args.parent_id.as_deref());
    builder = builder.query("page_token", args.page_token.as_deref());
    builder = builder.query("page_size", args.page_size.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: OrganizationListOrganizationsResponse = serde_json::from_slice(&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 /organizations
// -----------------------------------------------------------------------------

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

/// GET /organizations/{organization_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 = organizations_retrieve_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn organizations_retrieve_request<F>(
    client: DynNetClient,
    args: &OrganizationsRetrieveArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<OrganizationsRetrieveResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}",
        args.organization_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: OrganizationsRetrieveResponse = serde_json::from_slice(&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 /organizations/{organization_id}
// -----------------------------------------------------------------------------

/// PUT /organizations/{organization_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 = organizations_modify_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn organizations_modify_request<F>(
    client: DynNetClient,
    args: &OrganizationsModifyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<OrganizationsModifyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}",
        args.organization_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: OrganizationsModifyResponse = serde_json::from_slice(&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 /organizations/{organization_id}
// -----------------------------------------------------------------------------

/// DELETE /organizations/{organization_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 = organizations_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn organizations_delete_request<F>(
    client: DynNetClient,
    args: &OrganizationsDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<OrganizationsDeleteResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}",
        args.organization_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: OrganizationsDeleteResponse = serde_json::from_slice(&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 /organizations/{organization_id}/accounts
// -----------------------------------------------------------------------------

/// GET /organizations/{organization_id}/accounts.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = organizations_get_accounts_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn organizations_get_accounts_request<F>(
    client: DynNetClient,
    args: &OrganizationsGetAccountsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<OrganizationsGetAccountsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}/accounts",
        args.organization_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("account_pubname", args.account_pubname.as_deref());
    builder = builder.query("account_pubname.startsWith", args.account_pubname_starts_with.as_deref());
    builder = builder.query("account_pubname.endsWith", args.account_pubname_ends_with.as_deref());
    builder = builder.query("account_pubname.contains", args.account_pubname_contains.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("name.startsWith", args.name_starts_with.as_deref());
    builder = builder.query("name.endsWith", args.name_ends_with.as_deref());
    builder = builder.query("name.contains", args.name_contains.as_deref());
    builder = builder.query("order_by", args.order_by.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("page_token", args.page_token.as_deref());
    builder = builder.query("page_size", args.page_size.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: OrganizationsGetAccountsResponse = serde_json::from_slice(&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 /organizations/{organization_id}/logs/audit
// -----------------------------------------------------------------------------

/// GET /organizations/{organization_id}/logs/audit.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = audit_logs_v2_get_organization_audit_logs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn audit_logs_v2_get_organization_audit_logs_request<F>(
    client: DynNetClient,
    args: &AuditLogsV2GetOrganizationAuditLogsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<AaaAuditLogsV2OrgResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}/logs/audit",
        args.organization_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("action_result", args.action_result.as_deref());
    builder = builder.query("action_type", args.action_type.as_deref());
    builder = builder.query("actor_context", args.actor_context.as_deref());
    builder = builder.query("actor_email", args.actor_email.as_deref());
    builder = builder.query("actor_id", args.actor_id.as_deref());
    builder = builder.query("actor_ip_address", args.actor_ip_address.as_deref());
    builder = builder.query("actor_token_id", args.actor_token_id.as_deref());
    builder = builder.query("actor_token_name", args.actor_token_name.as_deref());
    builder = builder.query("actor_type", args.actor_type.as_deref());
    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("raw_cf_ray_id", args.raw_cf_ray_id.as_deref());
    builder = builder.query("raw_method", args.raw_method.as_deref());
    builder = builder.query("raw_status_code", args.raw_status_code.as_deref());
    builder = builder.query("raw_uri", args.raw_uri.as_deref());
    builder = builder.query("resource_id", args.resource_id.as_deref());
    builder = builder.query("resource_product", args.resource_product.as_deref());
    builder = builder.query("resource_type", args.resource_type.as_deref());
    builder = builder.query("resource_scope", args.resource_scope.as_deref());
    builder = builder.query("action_result.not", args.action_result_not.as_deref());
    builder = builder.query("action_type.not", args.action_type_not.as_deref());
    builder = builder.query("actor_context.not", args.actor_context_not.as_deref());
    builder = builder.query("actor_email.not", args.actor_email_not.as_deref());
    builder = builder.query("actor_id.not", args.actor_id_not.as_deref());
    builder = builder.query("actor_ip_address.not", args.actor_ip_address_not.as_deref());
    builder = builder.query("actor_token_id.not", args.actor_token_id_not.as_deref());
    builder = builder.query("actor_token_name.not", args.actor_token_name_not.as_deref());
    builder = builder.query("actor_type.not", args.actor_type_not.as_deref());
    builder = builder.query("id.not", args.id_not.as_deref());
    builder = builder.query("raw_cf_ray_id.not", args.raw_cf_ray_id_not.as_deref());
    builder = builder.query("raw_method.not", args.raw_method_not.as_deref());
    builder = builder.query("raw_status_code.not", args.raw_status_code_not.as_deref());
    builder = builder.query("raw_uri.not", args.raw_uri_not.as_deref());
    builder = builder.query("resource_id.not", args.resource_id_not.as_deref());
    builder = builder.query("resource_product.not", args.resource_product_not.as_deref());
    builder = builder.query("resource_type.not", args.resource_type_not.as_deref());
    builder = builder.query("resource_scope.not", args.resource_scope_not.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("before", args.before.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("limit", args.limit.as_deref());
    builder = builder.query("cursor", args.cursor.as_deref());

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: AaaAuditLogsV2OrgResponseCollection = serde_json::from_slice(&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 /organizations/{organization_id}/members
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("status", args.status.as_deref());
    builder = builder.query("user.email", args.user_email.as_deref());
    builder = builder.query("user.email.contains", args.user_email_contains.as_deref());
    builder = builder.query("user.email.startsWith", args.user_email_starts_with.as_deref());
    builder = builder.query("user.email.endsWith", args.user_email_ends_with.as_deref());
    builder = builder.query("page_token", args.page_token.as_deref());
    builder = builder.query("page_size", args.page_size.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: MembersListResponse = serde_json::from_slice(&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 /organizations/{organization_id}/members
// -----------------------------------------------------------------------------

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

/// GET /organizations/{organization_id}/members/{member_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 = members_retrieve_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn members_retrieve_request<F>(
    client: DynNetClient,
    args: &MembersRetrieveArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MembersRetrieveResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}/members/{}",
        args.organization_id,
        args.member_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: MembersRetrieveResponse = serde_json::from_slice(&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 /organizations/{organization_id}/members/{member_id}
// -----------------------------------------------------------------------------

/// DELETE /organizations/{organization_id}/members/{member_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 = members_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn members_delete_request<F>(
    client: DynNetClient,
    args: &MembersDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/organizations/{}/members/{}",
        args.organization_id,
        args.member_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /organizations/{organization_id}/members:batchCreate
// -----------------------------------------------------------------------------

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

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

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

// -----------------------------------------------------------------------------
// GET /organizations/{organization_id}/shares
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("status", args.status.as_deref());
    builder = builder.query("kind", args.kind.as_deref());
    builder = builder.query("target_type", args.target_type.as_deref());
    builder = builder.query("resource_types", args.resource_types.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.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: ResourceSharingShareResponseCollection = serde_json::from_slice(&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 /tenants/{tenant_id}/memberships
// -----------------------------------------------------------------------------

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

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

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

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

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

    builder = builder.query("id", args.id.as_deref());
    builder = builder.query("export", args.export.as_deref());
    builder = builder.query("action.type", args.action_type.as_deref());
    builder = builder.query("actor.ip", args.actor_ip.as_deref());
    builder = builder.query("actor.email", args.actor_email.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("before", args.before.as_deref());
    builder = builder.query("zone.name", args.zone_name.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("hide_user_logs", args.hide_user_logs.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: AaaAuditLogsResponseCollection = serde_json::from_slice(&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 /user/invites
// -----------------------------------------------------------------------------

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

/// GET /user/invites/{invite_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 = user_s_invites_invitation_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_s_invites_invitation_details_request<F>(
    client: DynNetClient,
    args: &UserSInvitesInvitationDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleInviteResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/invites/{}",
        args.invite_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: IamSingleInviteResponse = serde_json::from_slice(&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 /user/invites/{invite_id}
// -----------------------------------------------------------------------------

/// PATCH /user/invites/{invite_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 = user_s_invites_respond_to_invitation_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_s_invites_respond_to_invitation_request<F>(
    client: DynNetClient,
    args: &UserSInvitesRespondToInvitationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleInviteResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/invites/{}",
        args.invite_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: IamSingleInviteResponse = serde_json::from_slice(&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 /user/load_balancers/monitors
// -----------------------------------------------------------------------------

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

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

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

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

/// PATCH /user/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 = load_balancer_monitors_patch_monitor_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_monitors_patch_monitor_request<F>(
    client: DynNetClient,
    args: &LoadBalancerMonitorsPatchMonitorArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingMonitorResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/monitors/{}",
        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 /user/load_balancers/monitors/{monitor_id}
// -----------------------------------------------------------------------------

/// DELETE /user/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 = load_balancer_monitors_delete_monitor_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_monitors_delete_monitor_request<F>(
    client: DynNetClient,
    args: &LoadBalancerMonitorsDeleteMonitorArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/monitors/{}",
        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 /user/load_balancers/monitors/{monitor_id}/preview
// -----------------------------------------------------------------------------

/// POST /user/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 = load_balancer_monitors_preview_monitor_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_monitors_preview_monitor_request<F>(
    client: DynNetClient,
    args: &LoadBalancerMonitorsPreviewMonitorArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingPreviewResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/monitors/{}/preview",
        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 /user/load_balancers/monitors/{monitor_id}/references
// -----------------------------------------------------------------------------

/// GET /user/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 = load_balancer_monitors_list_monitor_references_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_monitors_list_monitor_references_request<F>(
    client: DynNetClient,
    args: &LoadBalancerMonitorsListMonitorReferencesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingMonitorReferencesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/monitors/{}/references",
        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 /user/load_balancers/pools
// -----------------------------------------------------------------------------

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

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

/// PATCH /user/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 = load_balancer_pools_patch_pools_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_patch_pools_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsPatchPoolsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools",
    );
    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 /user/load_balancers/pools/{pool_id}
// -----------------------------------------------------------------------------

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

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

/// PATCH /user/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 = load_balancer_pools_patch_pool_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_patch_pool_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsPatchPoolArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingSchemasSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools/{}",
        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 /user/load_balancers/pools/{pool_id}
// -----------------------------------------------------------------------------

/// DELETE /user/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 = load_balancer_pools_delete_pool_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_delete_pool_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsDeletePoolArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingSchemasIdResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools/{}",
        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 /user/load_balancers/pools/{pool_id}/health
// -----------------------------------------------------------------------------

/// GET /user/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 = load_balancer_pools_pool_health_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_pool_health_details_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsPoolHealthDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingHealthDetails>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools/{}/health",
        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 /user/load_balancers/pools/{pool_id}/preview
// -----------------------------------------------------------------------------

/// POST /user/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 = load_balancer_pools_preview_pool_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_preview_pool_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsPreviewPoolArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingPreviewResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools/{}/preview",
        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 /user/load_balancers/pools/{pool_id}/references
// -----------------------------------------------------------------------------

/// GET /user/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 = load_balancer_pools_list_pool_references_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_pools_list_pool_references_request<F>(
    client: DynNetClient,
    args: &LoadBalancerPoolsListPoolReferencesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingPoolsReferencesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/pools/{}/references",
        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 /user/load_balancers/preview/{preview_id}
// -----------------------------------------------------------------------------

/// GET /user/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 = load_balancer_monitors_preview_result_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_monitors_preview_result_request<F>(
    client: DynNetClient,
    args: &LoadBalancerMonitorsPreviewResultArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingPreviewResultResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancers/preview/{}",
        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 /user/load_balancing_analytics/events
// -----------------------------------------------------------------------------

/// GET /user/load_balancing_analytics/events.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = load_balancer_healthcheck_events_list_healthcheck_events_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn load_balancer_healthcheck_events_list_healthcheck_events_request<F>(
    client: DynNetClient,
    args: &LoadBalancerHealthcheckEventsListHealthcheckEventsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<LoadBalancingComponentsSchemasResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/load_balancing_analytics/events",
    );
    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("until", args.until.as_deref());
    builder = builder.query("pool_name", args.pool_name.as_deref());
    builder = builder.query("origin_healthy", args.origin_healthy.as_deref());
    builder = builder.query("pool_id", args.pool_id.as_deref());
    builder = builder.query("since", args.since.as_deref());
    builder = builder.query("origin_name", args.origin_name.as_deref());
    builder = builder.query("pool_healthy", args.pool_healthy.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: LoadBalancingComponentsSchemasResponseCollection = serde_json::from_slice(&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 /user/subscriptions
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamCollectionTokensResponse = serde_json::from_slice(&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 /user/tokens
// -----------------------------------------------------------------------------

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

/// GET /user/tokens/permission_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 = permission_groups_list_permission_groups_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn permission_groups_list_permission_groups_request<F>(
    client: DynNetClient,
    args: &PermissionGroupsListPermissionGroupsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamPermissionsGroupResponseCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/permission_groups",
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::get(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("scope", args.scope.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: IamPermissionsGroupResponseCollection = serde_json::from_slice(&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 /user/tokens/verify
// -----------------------------------------------------------------------------

/// GET /user/tokens/verify.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = user_api_tokens_verify_token_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_api_tokens_verify_token_request<F>(
    client: DynNetClient,
    _args: &UserApiTokensVerifyTokenArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamTokenVerifyResponseSingleSegment>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/verify",
    );
    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: IamTokenVerifyResponseSingleSegment = serde_json::from_slice(&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 /user/tokens/{token_id}
// -----------------------------------------------------------------------------

/// GET /user/tokens/{token_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 = user_api_tokens_token_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_api_tokens_token_details_request<F>(
    client: DynNetClient,
    args: &UserApiTokensTokenDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleTokenResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/{}",
        args.token_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: IamSingleTokenResponse = serde_json::from_slice(&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 /user/tokens/{token_id}
// -----------------------------------------------------------------------------

/// PUT /user/tokens/{token_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 = user_api_tokens_update_token_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_api_tokens_update_token_request<F>(
    client: DynNetClient,
    args: &UserApiTokensUpdateTokenArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamSingleTokenResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/{}",
        args.token_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: IamSingleTokenResponse = serde_json::from_slice(&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 /user/tokens/{token_id}
// -----------------------------------------------------------------------------

/// DELETE /user/tokens/{token_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 = user_api_tokens_delete_token_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_api_tokens_delete_token_request<F>(
    client: DynNetClient,
    args: &UserApiTokensDeleteTokenArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamApiResponseSingleId>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/{}",
        args.token_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: IamApiResponseSingleId = serde_json::from_slice(&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 /user/tokens/{token_id}/value
// -----------------------------------------------------------------------------

/// PUT /user/tokens/{token_id}/value.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = user_api_tokens_roll_token_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_api_tokens_roll_token_request<F>(
    client: DynNetClient,
    args: &UserApiTokensRollTokenArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<IamResponseSingleValue>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/user/tokens/{}/value",
        args.token_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: IamResponseSingleValue = serde_json::from_slice(&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 /users/tenants
// -----------------------------------------------------------------------------

/// GET /users/tenants.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = user_list_user_tenants_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn user_list_user_tenants_request<F>(
    client: DynNetClient,
    _args: &UserListUserTenantsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<UserListUserTenantsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/users/tenants",
    );
    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: UserListUserTenantsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}