foundation_deployment_cloudflare 0.1.2

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

#![cfg(feature = "cloudflare_email")]
#![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;

use super::shared::ApiResponse;

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

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

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

/// `DlpCreateEmailRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCreateEmailRule {
    /// action property.
    pub action: DlpEmailRuleAction,
    /// conditions property.
    pub conditions: Vec<DlpEmailRuleCondition>,
    /// description property.
    pub description: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// name property.
    pub name: String,
}

/// `DlpEmailRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEmailRule {
    /// action property.
    pub action: DlpEmailRuleAction,
    /// conditions property.
    pub conditions: Vec<DlpEmailRuleCondition>,
    /// created_at property.
    pub created_at: String,
    /// description property.
    pub description: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// name property.
    pub name: String,
    /// priority property.
    pub priority: i64,
    /// rule_id property.
    pub rule_id: String,
    /// updated_at property.
    pub updated_at: String,
}

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

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

/// `DlpEmailRuleCondition` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEmailRuleCondition {
    /// operator property.
    pub operator: DlpEmailRuleOperator,
    /// selector property.
    pub selector: DlpEmailRuleSelector,
    /// value property.
    pub value: DlpEmailRuleValue,
}

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

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

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

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

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

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

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

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

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

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

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

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

/// `DlpUpdateAddinAccountMapping` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpUpdateAddinAccountMapping {
    /// auth_requirements property.
    pub auth_requirements: DlpAddinAuth,
}

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

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

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

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

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

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

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

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

/// `EmailDestinationAddressProperties` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailDestinationAddressProperties {
    /// created property.
    pub created: Option<EmailCreated>,
    /// email property.
    pub email: Option<EmailEmail>,
    /// id property.
    pub id: Option<EmailDestinationAddressIdentifier>,
    /// modified property.
    pub modified: Option<EmailModified>,
    /// tag property.
    pub tag: Option<EmailDestinationAddressTag>,
    /// verified property.
    pub verified: Option<EmailVerified>,
}

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

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

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

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

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

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

/// `EmailSecurityAllowPolicy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityAllowPolicy {
    /// `comments` property.
    pub comments: Option<String>,
    /// `created_at` property.
    pub created_at: String,
    /// `id` property.
    pub id: EmailSecurityAllowPolicyId,
    /// `is_acceptable_sender` property.
    pub is_acceptable_sender: bool,
    /// `is_exempt_recipient` property.
    pub is_exempt_recipient: bool,
    /// `is_recipient` property.
    pub is_recipient: Option<bool>,
    /// `is_regex` property.
    pub is_regex: bool,
    /// `is_sender` property.
    pub is_sender: Option<bool>,
    /// `is_spoof` property.
    pub is_spoof: Option<bool>,
    /// `is_trusted_sender` property.
    pub is_trusted_sender: bool,
    /// `last_modified` property.
    pub last_modified: String,
    /// `pattern` property.
    pub pattern: String,
    /// `pattern_type` property.
    pub pattern_type: EmailSecurityPatternType,
    /// `verify_sender` property.
    pub verify_sender: bool,
}

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

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

/// `EmailSecurityAttachment` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityAttachment {
    /// content_type property.
    pub content_type: Option<String>,
    /// detection property.
    pub detection: Option<serde_json::Value>,
    /// encrypted property.
    pub encrypted: Option<bool>,
    /// name property.
    pub name: Option<String>,
    /// size property.
    pub size: i64,
}

/// `EmailSecurityBatchAllowPoliciesRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityBatchAllowPoliciesRequest {
    /// deletes property.
    pub deletes: Vec<EmailSecurityBatchAllowPoliciesRequestDeletesItem>,
    /// patches property.
    pub patches: Vec<serde_json::Value>,
    /// posts property.
    pub posts: Vec<EmailSecurityCreateAllowPolicy>,
    /// puts property.
    pub puts: Vec<serde_json::Value>,
}

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

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

/// `EmailSecurityBatchBlockedSendersRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityBatchBlockedSendersRequest {
    /// deletes property.
    pub deletes: Vec<EmailSecurityBatchBlockedSendersRequestDeletesItem>,
    /// patches property.
    pub patches: Vec<serde_json::Value>,
    /// posts property.
    pub posts: Vec<EmailSecurityCreateBlockedSender>,
    /// puts property.
    pub puts: Vec<serde_json::Value>,
}

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

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

/// `EmailSecurityBlockedSender` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityBlockedSender {
    /// `comments` property.
    pub comments: Option<String>,
    /// `created_at` property.
    pub created_at: String,
    /// `id` property.
    pub id: EmailSecurityBlockedSenderId,
    /// `is_regex` property.
    pub is_regex: bool,
    /// `last_modified` property.
    pub last_modified: String,
    /// `pattern` property.
    pub pattern: String,
    /// `pattern_type` property.
    pub pattern_type: EmailSecurityPatternType,
}

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

/// `EmailSecurityCreateAllowPolicy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityCreateAllowPolicy {
    /// comments property.
    pub comments: Option<String>,
    /// is_acceptable_sender property.
    pub is_acceptable_sender: bool,
    /// is_exempt_recipient property.
    pub is_exempt_recipient: bool,
    /// is_recipient property.
    pub is_recipient: Option<bool>,
    /// is_regex property.
    pub is_regex: bool,
    /// is_sender property.
    pub is_sender: Option<bool>,
    /// is_spoof property.
    pub is_spoof: Option<bool>,
    /// is_trusted_sender property.
    pub is_trusted_sender: bool,
    /// pattern property.
    pub pattern: String,
    /// pattern_type property.
    pub pattern_type: EmailSecurityPatternType,
    /// verify_sender property.
    pub verify_sender: bool,
}

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

/// `EmailSecurityCreateBlockedSender` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityCreateBlockedSender {
    /// comments property.
    pub comments: Option<String>,
    /// is_regex property.
    pub is_regex: bool,
    /// pattern property.
    pub pattern: String,
    /// pattern_type property.
    pub pattern_type: EmailSecurityPatternType,
}

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

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

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

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

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

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

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

/// `EmailSecurityDisplayName` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityDisplayName {
    /// `comments` property.
    pub comments: Option<String>,
    /// `created_at` property.
    pub created_at: String,
    /// `directory_id` property.
    pub directory_id: Option<serde_json::Value>,
    /// `directory_node_id` property.
    pub directory_node_id: Option<serde_json::Value>,
    /// `email` property.
    pub email: String,
    /// `external_directory_node_id` property.
    pub external_directory_node_id: Option<String>,
    /// `id` property.
    pub id: i64,
    /// `is_email_regex` property.
    pub is_email_regex: bool,
    /// `last_modified` property.
    pub last_modified: String,
    /// `name` property.
    pub name: String,
    /// `provenance` property.
    pub provenance: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

/// `EmailSecurityInvestigateMessage` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityInvestigateMessage {
    /// action_log property.
    pub action_log: serde_json::Value,
    /// alert_id property.
    pub alert_id: Option<String>,
    /// client_recipients property.
    pub client_recipients: Vec<String>,
    /// delivery_mode property.
    pub delivery_mode: Option<serde_json::Value>,
    /// detection_reasons property.
    pub detection_reasons: Vec<String>,
    /// edf_hash property.
    pub edf_hash: Option<String>,
    /// envelope_from property.
    pub envelope_from: Option<String>,
    /// envelope_to property.
    pub envelope_to: Option<Vec<String>>,
    /// final_disposition property.
    pub final_disposition: Option<serde_json::Value>,
    /// findings property.
    pub findings: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
    /// from property.
    pub from: Option<String>,
    /// from_name property.
    pub from_name: Option<String>,
    /// htmltext_structure_hash property.
    pub htmltext_structure_hash: Option<String>,
    /// id property.
    pub id: String,
    /// is_phish_submission property.
    pub is_phish_submission: bool,
    /// is_quarantined property.
    pub is_quarantined: bool,
    /// message_id property.
    pub message_id: Option<String>,
    /// post_delivery_operations property.
    pub post_delivery_operations: Option<Vec<String>>,
    /// postfix_id property.
    pub postfix_id: EmailSecurityPostfixId,
    /// postfix_id_outbound property.
    pub postfix_id_outbound: Option<String>,
    /// properties property.
    pub properties: std::collections::HashMap<String, serde_json::Value>,
    /// replyto property.
    pub replyto: Option<String>,
    /// scanned_at property.
    pub scanned_at: Option<String>,
    /// sent_at property.
    pub sent_at: Option<String>,
    /// sent_date property.
    pub sent_date: Option<String>,
    /// subject property.
    pub subject: Option<String>,
    /// threat_categories property.
    pub threat_categories: Option<Vec<String>>,
    /// to property.
    pub to: Option<Vec<String>>,
    /// to_name property.
    pub to_name: Option<Vec<String>>,
    /// ts property.
    pub ts: String,
    /// validation property.
    pub validation: Option<serde_json::Value>,
}

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

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

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

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

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

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

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

/// `EmailSecurityMoveResponseItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityMoveResponseItem {
    /// completed_at property.
    pub completed_at: Option<String>,
    /// completed_timestamp property.
    pub completed_timestamp: String,
    /// destination property.
    pub destination: Option<String>,
    /// item_count property.
    pub item_count: i64,
    /// message_id property.
    pub message_id: Option<String>,
    /// operation property.
    pub operation: Option<String>,
    /// recipient property.
    pub recipient: Option<String>,
    /// status property.
    pub status: Option<String>,
    /// success property.
    pub success: bool,
}

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

/// `EmailSecurityPhishGuardReport` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityPhishGuardReport {
    /// content property.
    pub content: String,
    /// created_at property.
    pub created_at: String,
    /// disposition property.
    pub disposition: EmailSecurityDispositionLabel,
    /// fields property.
    pub fields: std::collections::HashMap<String, serde_json::Value>,
    /// id property.
    pub id: i64,
    /// priority property.
    pub priority: String,
    /// tags property.
    pub tags: Option<Vec<EmailSecurityPhishGuardReportTag>>,
    /// title property.
    pub title: String,
    /// ts property.
    pub ts: String,
    /// updated_at property.
    pub updated_at: String,
}

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

/// `EmailSecurityPostBulkMessageMoveRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityPostBulkMessageMoveRequest {
    /// destination property.
    pub destination: String,
    /// ids property.
    pub ids: Option<Vec<String>>,
    /// postfix_ids property.
    pub postfix_ids: Option<Vec<EmailSecurityPostfixId>>,
}

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

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

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

/// `EmailSecurityPostPreviewRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityPostPreviewRequest {
    /// postfix_id property.
    pub postfix_id: EmailSecurityPostfixId,
}

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

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

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

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

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

/// `EmailSecurityReleaseResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityReleaseResponse {
    /// `delivered` property.
    pub delivered: Option<Vec<String>>,
    /// `failed` property.
    pub failed: Option<Vec<String>>,
    /// `id` property.
    pub id: String,
    /// `postfix_id` property.
    pub postfix_id: EmailSecurityPostfixId,
    /// `undelivered` property.
    pub undelivered: Option<Vec<String>>,
}

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

/// `EmailSecuritySubmission` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecuritySubmission {
    /// customer_status property.
    pub customer_status: Option<serde_json::Value>,
    /// escalated_as property.
    pub escalated_as: Option<serde_json::Value>,
    /// escalated_at property.
    pub escalated_at: Option<String>,
    /// escalated_by property.
    pub escalated_by: Option<String>,
    /// escalated_submission_id property.
    pub escalated_submission_id: Option<String>,
    /// original_disposition property.
    pub original_disposition: Option<serde_json::Value>,
    /// original_edf_hash property.
    pub original_edf_hash: Option<String>,
    /// original_postfix_id property.
    pub original_postfix_id: Option<String>,
    /// outcome property.
    pub outcome: Option<String>,
    /// outcome_disposition property.
    pub outcome_disposition: Option<serde_json::Value>,
    /// requested_at property.
    pub requested_at: Option<String>,
    /// requested_by property.
    pub requested_by: Option<String>,
    /// requested_disposition property.
    pub requested_disposition: Option<serde_json::Value>,
    /// requested_ts property.
    pub requested_ts: String,
    /// status property.
    pub status: Option<String>,
    /// subject property.
    pub subject: Option<String>,
    /// submission_id property.
    pub submission_id: String,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<String>,
}

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

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

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

/// `EmailSecurityUpdateAllowPolicy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityUpdateAllowPolicy {
    /// comments property.
    pub comments: Option<String>,
    /// is_acceptable_sender property.
    pub is_acceptable_sender: Option<bool>,
    /// is_exempt_recipient property.
    pub is_exempt_recipient: Option<bool>,
    /// is_regex property.
    pub is_regex: Option<bool>,
    /// is_trusted_sender property.
    pub is_trusted_sender: Option<bool>,
    /// pattern property.
    pub pattern: Option<String>,
    /// pattern_type property.
    pub pattern_type: Option<serde_json::Value>,
    /// verify_sender property.
    pub verify_sender: Option<bool>,
}

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

/// `EmailSecurityUpdateBlockedSender` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSecurityUpdateBlockedSender {
    /// comments property.
    pub comments: Option<String>,
    /// is_regex property.
    pub is_regex: Option<bool>,
    /// pattern property.
    pub pattern: Option<String>,
    /// pattern_type property.
    pub pattern_type: Option<serde_json::Value>,
}

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

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

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

/// `EmailSendingAccountSendBuilderResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingAccountSendBuilderResponse {
    /// errors property.
    pub errors: Vec<EmailSendingAccountSendBuilderResponseErrorsItem>,
    /// messages property.
    pub messages: Vec<EmailSendingAccountSendBuilderResponseMessagesItem>,
    /// result property.
    pub result: EmailSendingEmailSendResponse,
    /// result_info property.
    pub result_info: Option<EmailSendingAccountSendBuilderResponseResultInfo>,
    /// success property.
    pub success: bool,
}

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

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

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

/// `EmailSendingAccountSendRawMessageResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingAccountSendRawMessageResponse {
    /// errors property.
    pub errors: Vec<EmailSendingAccountSendRawMessageResponseErrorsItem>,
    /// messages property.
    pub messages: Vec<EmailSendingAccountSendRawMessageResponseMessagesItem>,
    /// result property.
    pub result: EmailSendingEmailSendResponse,
    /// result_info property.
    pub result_info: Option<EmailSendingAccountSendRawMessageResponseResultInfo>,
    /// success property.
    pub success: bool,
}

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

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

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

/// `EmailSendingEmailAttachment` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingEmailAttachment {
    /// content property.
    pub content: String,
    /// disposition property.
    pub disposition: String,
    /// filename property.
    pub filename: String,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// `EmailSendingEmailBuilder` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingEmailBuilder {
    /// attachments property.
    pub attachments: Option<Vec<serde_json::Value>>,
    /// bcc property.
    pub bcc: Option<serde_json::Value>,
    /// cc property.
    pub cc: Option<serde_json::Value>,
    /// from property.
    pub from: serde_json::Value,
    /// headers property.
    pub headers: Option<serde_json::Value>,
    /// html property.
    pub html: Option<String>,
    /// reply_to property.
    pub reply_to: Option<serde_json::Value>,
    /// subject property.
    pub subject: String,
    /// text property.
    pub text: Option<String>,
    /// to property.
    pub to: serde_json::Value,
}

/// `EmailSendingEmailInlineAttachment` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingEmailInlineAttachment {
    /// content property.
    pub content: String,
    /// content_id property.
    pub content_id: String,
    /// disposition property.
    pub disposition: String,
    /// filename property.
    pub filename: String,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// `EmailSendingEmailSendResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingEmailSendResponse {
    /// delivered property.
    pub delivered: Vec<String>,
    /// permanent_bounces property.
    pub permanent_bounces: Vec<String>,
    /// queued property.
    pub queued: Vec<String>,
}

/// `EmailSendingSendRawRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct EmailSendingSendRawRequest {
    /// from property.
    pub from: String,
    /// mime_message property.
    pub mime_message: String,
    /// recipients property.
    pub recipients: Vec<String>,
}

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

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

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

/// `RadarGetEmailRoutingSummaryResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingSummaryResponseResultMeta {
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetEmailRoutingSummaryResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetEmailRoutingSummaryResponseResultMetaUnitsItem>,
}

/// `RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingSummaryResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetEmailRoutingSummaryResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingSummaryResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

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

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

/// `RadarGetEmailRoutingTimeseriesGroupResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupResponseResult {
    /// meta property.
    pub meta: RadarGetEmailRoutingTimeseriesGroupResponseResultMeta,
    /// serie_0 property.
    pub serie_0: RadarGetEmailRoutingTimeseriesGroupResponseResultSerie0,
}

/// `RadarGetEmailRoutingTimeseriesGroupResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupResponseResultMeta {
    /// aggInterval property.
    #[serde(rename = "aggInterval")]
    pub agg_interval: String,
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetEmailRoutingTimeseriesGroupResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetEmailRoutingTimeseriesGroupResponseResultMetaUnitsItem>,
}

/// `RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetEmailRoutingTimeseriesGroupResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

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

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

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

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

/// `RadarGetEmailSecuritySummaryResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecuritySummaryResponseResultMeta {
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetEmailSecuritySummaryResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetEmailSecuritySummaryResponseResultMetaUnitsItem>,
}

/// `RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecuritySummaryResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetEmailSecuritySummaryResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecuritySummaryResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

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

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

/// `RadarGetEmailSecurityTimeseriesGroupResponseResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupResponseResult {
    /// meta property.
    pub meta: RadarGetEmailSecurityTimeseriesGroupResponseResultMeta,
    /// serie_0 property.
    pub serie_0: RadarGetEmailSecurityTimeseriesGroupResponseResultSerie0,
}

/// `RadarGetEmailSecurityTimeseriesGroupResponseResultMeta` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupResponseResultMeta {
    /// aggInterval property.
    #[serde(rename = "aggInterval")]
    pub agg_interval: String,
    /// confidenceInfo property.
    #[serde(rename = "confidenceInfo")]
    pub confidence_info: RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfo,
    /// dateRange property.
    #[serde(rename = "dateRange")]
    pub date_range: Vec<RadarGetEmailSecurityTimeseriesGroupResponseResultMetaDateRangeItem>,
    /// lastUpdated property.
    #[serde(rename = "lastUpdated")]
    pub last_updated: String,
    /// normalization property.
    pub normalization: String,
    /// units property.
    pub units: Vec<RadarGetEmailSecurityTimeseriesGroupResponseResultMetaUnitsItem>,
}

/// `RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfo {
    /// annotations property.
    pub annotations: Vec<RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
    /// level property.
    pub level: i64,
}

/// `RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem {
    /// dataSource property.
    #[serde(rename = "dataSource")]
    pub data_source: String,
    /// description property.
    pub description: String,
    /// endDate property.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// eventType property.
    #[serde(rename = "eventType")]
    pub event_type: String,
    /// isInstantaneous property.
    #[serde(rename = "isInstantaneous")]
    pub is_instantaneous: bool,
    /// linkedUrl property.
    #[serde(rename = "linkedUrl")]
    pub linked_url: String,
    /// startDate property.
    #[serde(rename = "startDate")]
    pub start_date: String,
}

/// `RadarGetEmailSecurityTimeseriesGroupResponseResultMetaDateRangeItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupResponseResultMetaDateRangeItem {
    /// endTime property.
    #[serde(rename = "endTime")]
    pub end_time: String,
    /// startTime property.
    #[serde(rename = "startTime")]
    pub start_time: String,
}

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

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

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

/// Arguments for [`dlp-email-scanner-get-account-mapping_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerGetAccountMappingArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-email-scanner-create-account-mapping_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerCreateAccountMappingArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpUpdateAddinAccountMapping,
}

/// Arguments for [`dlp-email-scanner-list-all-rules_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerListAllRulesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-email-scanner-create-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerCreateRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpCreateEmailRule,
}

/// Arguments for [`dlp-email-scanner-update-rule-priorities_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerUpdateRulePrioritiesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpUpdateEmailRulePriorities,
}

/// Arguments for [`dlp-email-scanner-get-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerGetRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`dlp-email-scanner-update-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerUpdateRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
    /// Request body.
    pub body: DlpCreateEmailRule,
}

/// Arguments for [`dlp-email-scanner-delete-rule_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEmailScannerDeleteRuleArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `rule_id`.
    pub rule_id: String,
}

/// Arguments for [`email_security_investigate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSecurityInvestigateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `start`.
    pub start: Option<String>,
    /// Query parameter: `end`.
    pub end: Option<String>,
    /// Query parameter: `query`.
    pub query: Option<String>,
    /// Query parameter: `detections_only`.
    pub detections_only: Option<String>,
    /// Query parameter: `action_log`.
    pub action_log: Option<String>,
    /// Query parameter: `final_disposition`.
    pub final_disposition: Option<String>,
    /// Query parameter: `metric`.
    pub metric: Option<String>,
    /// Query parameter: `message_action`.
    pub message_action: Option<String>,
    /// Query parameter: `recipient`.
    pub recipient: Option<String>,
    /// Query parameter: `sender`.
    pub sender: Option<String>,
    /// Query parameter: `alert_id`.
    pub alert_id: Option<String>,
    /// Query parameter: `domain`.
    pub domain: Option<String>,
    /// Query parameter: `message_id`.
    pub message_id: Option<String>,
    /// Query parameter: `subject`.
    pub subject: Option<String>,
    /// Query parameter: `exact_subject`.
    pub exact_subject: Option<String>,
    /// Query parameter: `submissions`.
    pub submissions: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

/// Arguments for [`email_security_get_phishguard_reports_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSecurityGetPhishguardReportsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `from_date`.
    pub from_date: Option<String>,
    /// Query parameter: `to_date`.
    pub to_date: Option<String>,
    /// Query parameter: `start`.
    pub start: Option<String>,
    /// Query parameter: `end`.
    pub end: Option<String>,
}

/// Arguments for [`email_security_list_allow_policies_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSecurityListAllowPoliciesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `search`.
    pub search: Option<String>,
    /// Query parameter: `is_sender`.
    pub is_sender: Option<String>,
    /// Query parameter: `is_trusted_sender`.
    pub is_trusted_sender: Option<String>,
    /// Query parameter: `is_recipient`.
    pub is_recipient: Option<String>,
    /// Query parameter: `is_exempt_recipient`.
    pub is_exempt_recipient: Option<String>,
    /// Query parameter: `is_spoof`.
    pub is_spoof: Option<String>,
    /// Query parameter: `is_acceptable_sender`.
    pub is_acceptable_sender: Option<String>,
    /// Query parameter: `verify_sender`.
    pub verify_sender: Option<String>,
    /// Query parameter: `pattern_type`.
    pub pattern_type: Option<String>,
    /// Query parameter: `pattern`.
    pub pattern: Option<String>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Arguments for [`email_security_submissions_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSecuritySubmissionsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `start`.
    pub start: Option<String>,
    /// Query parameter: `end`.
    pub end: Option<String>,
    /// Query parameter: `type`.
    pub r#type: Option<String>,
    /// Query parameter: `submission_id`.
    pub submission_id: Option<String>,
    /// Query parameter: `original_disposition`.
    pub original_disposition: Option<String>,
    /// Query parameter: `requested_disposition`.
    pub requested_disposition: Option<String>,
    /// Query parameter: `outcome_disposition`.
    pub outcome_disposition: Option<String>,
    /// Query parameter: `status`.
    pub status: Option<String>,
    /// Query parameter: `query`.
    pub query: Option<String>,
    /// Query parameter: `customer_status`.
    pub customer_status: Option<String>,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
}

/// Arguments for [`email-routing-destination-addresses-list-destination-addresses_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailRoutingDestinationAddressesListDestinationAddressesArgs {
    /// 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: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `verified`.
    pub verified: Option<String>,
}

/// Arguments for [`email-routing-destination-addresses-create-a-destination-address_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailRoutingDestinationAddressesCreateADestinationAddressArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: EmailCreateDestinationAddressProperties,
}

/// Arguments for [`email-routing-destination-addresses-get-a-destination-address_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailRoutingDestinationAddressesGetADestinationAddressArgs {
    /// Path parameter: `destination_address_identifier`.
    pub destination_address_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`email-routing-destination-addresses-delete-destination-address_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailRoutingDestinationAddressesDeleteDestinationAddressArgs {
    /// Path parameter: `destination_address_identifier`.
    pub destination_address_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`email-sending-account-send-builder_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSendingAccountSendBuilderArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: EmailSendingEmailBuilder,
}

/// Arguments for [`email-sending-account-send-raw-message_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EmailSendingAccountSendRawMessageArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: EmailSendingSendRawRequest,
}

/// Arguments for [`radar-get-email-routing-summary_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEmailRoutingSummaryArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `arc`.
    pub arc: Option<String>,
    /// Query parameter: `dkim`.
    pub dkim: Option<String>,
    /// Query parameter: `dmarc`.
    pub dmarc: Option<String>,
    /// Query parameter: `spf`.
    pub spf: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `encrypted`.
    pub encrypted: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-email-routing-timeseries-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEmailRoutingTimeseriesGroupArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `aggInterval`.
    pub agg_interval: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `arc`.
    pub arc: Option<String>,
    /// Query parameter: `dkim`.
    pub dkim: Option<String>,
    /// Query parameter: `dmarc`.
    pub dmarc: Option<String>,
    /// Query parameter: `spf`.
    pub spf: Option<String>,
    /// Query parameter: `ipVersion`.
    pub ip_version: Option<String>,
    /// Query parameter: `encrypted`.
    pub encrypted: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-email-security-summary_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEmailSecuritySummaryArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `arc`.
    pub arc: Option<String>,
    /// Query parameter: `dkim`.
    pub dkim: Option<String>,
    /// Query parameter: `dmarc`.
    pub dmarc: Option<String>,
    /// Query parameter: `spf`.
    pub spf: Option<String>,
    /// Query parameter: `tlsVersion`.
    pub tls_version: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

/// Arguments for [`radar-get-email-security-timeseries-group_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEmailSecurityTimeseriesGroupArgs {
    /// Path parameter: `dimension`.
    pub dimension: String,
    /// Query parameter: `aggInterval`.
    pub agg_interval: Option<String>,
    /// Query parameter: `name`.
    pub name: Option<String>,
    /// Query parameter: `dateRange`.
    pub date_range: Option<String>,
    /// Query parameter: `dateStart`.
    pub date_start: Option<String>,
    /// Query parameter: `dateEnd`.
    pub date_end: Option<String>,
    /// Query parameter: `arc`.
    pub arc: Option<String>,
    /// Query parameter: `dkim`.
    pub dkim: Option<String>,
    /// Query parameter: `dmarc`.
    pub dmarc: Option<String>,
    /// Query parameter: `spf`.
    pub spf: Option<String>,
    /// Query parameter: `tlsVersion`.
    pub tls_version: Option<String>,
    /// Query parameter: `limitPerGroup`.
    pub limit_per_group: Option<String>,
    /// Query parameter: `format`.
    pub format: Option<String>,
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/email/account_mapping
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/email/account_mapping.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_email_scanner_get_account_mapping_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_email_scanner_get_account_mapping_request<F>(
    client: DynNetClient,
    args: &DlpEmailScannerGetAccountMappingArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEmailScannerGetAccountMappingResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/email/account_mapping",
        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: DlpEmailScannerGetAccountMappingResponse = serde_json::from_slice(&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}/dlp/email/account_mapping
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/email/account_mapping.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - 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_email_scanner_create_account_mapping_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_email_scanner_create_account_mapping_request<F>(
    client: DynNetClient,
    args: &DlpEmailScannerCreateAccountMappingArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEmailScannerCreateAccountMappingResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/email/account_mapping",
        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: DlpEmailScannerCreateAccountMappingResponse = serde_json::from_slice(&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}/dlp/email/rules
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// GET /accounts/{account_id}/email-security/investigate.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = email_security_investigate_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_investigate_request<F>(
    client: DynNetClient,
    args: &EmailSecurityInvestigateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityInvestigateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/investigate",
        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("start", args.start.as_deref());
    builder = builder.query("end", args.end.as_deref());
    builder = builder.query("query", args.query.as_deref());
    builder = builder.query("detections_only", args.detections_only.as_deref());
    builder = builder.query("action_log", args.action_log.as_deref());
    builder = builder.query("final_disposition", args.final_disposition.as_deref());
    builder = builder.query("metric", args.metric.as_deref());
    builder = builder.query("message_action", args.message_action.as_deref());
    builder = builder.query("recipient", args.recipient.as_deref());
    builder = builder.query("sender", args.sender.as_deref());
    builder = builder.query("alert_id", args.alert_id.as_deref());
    builder = builder.query("domain", args.domain.as_deref());
    builder = builder.query("message_id", args.message_id.as_deref());
    builder = builder.query("subject", args.subject.as_deref());
    builder = builder.query("exact_subject", args.exact_subject.as_deref());
    builder = builder.query("submissions", args.submissions.as_deref());
    builder = builder.query("cursor", args.cursor.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("page", args.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: EmailSecurityInvestigateResponse = serde_json::from_slice(&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}/email-security/investigate/move
// -----------------------------------------------------------------------------

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

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

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

/// GET /accounts/{account_id}/email-security/investigate/{postfix_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 = email_security_get_message_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_message_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetMessageArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetMessageResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/investigate/{}",
        args.account_id,
        args.postfix_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: EmailSecurityGetMessageResponse = serde_json::from_slice(&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}/email-security/investigate/{postfix_id}/detections
// -----------------------------------------------------------------------------

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

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

/// GET /accounts/{account_id}/email-security/investigate/{postfix_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 = email_security_get_message_preview_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_message_preview_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetMessagePreviewArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetMessagePreviewResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/investigate/{}/preview",
        args.account_id,
        args.postfix_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: EmailSecurityGetMessagePreviewResponse = serde_json::from_slice(&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}/email-security/investigate/{postfix_id}/raw
// -----------------------------------------------------------------------------

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

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

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

/// GET /accounts/{account_id}/email-security/phishguard/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 = email_security_get_phishguard_reports_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_phishguard_reports_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetPhishguardReportsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetPhishguardReportsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/phishguard/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("from_date", args.from_date.as_deref());
    builder = builder.query("to_date", args.to_date.as_deref());
    builder = builder.query("start", args.start.as_deref());
    builder = builder.query("end", args.end.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: EmailSecurityGetPhishguardReportsResponse = serde_json::from_slice(&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}/email-security/settings/allow_policies
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/email-security/settings/allow_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 = email_security_list_allow_policies_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_list_allow_policies_request<F>(
    client: DynNetClient,
    args: &EmailSecurityListAllowPoliciesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityListAllowPoliciesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/allow_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());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("search", args.search.as_deref());
    builder = builder.query("is_sender", args.is_sender.as_deref());
    builder = builder.query("is_trusted_sender", args.is_trusted_sender.as_deref());
    builder = builder.query("is_recipient", args.is_recipient.as_deref());
    builder = builder.query("is_exempt_recipient", args.is_exempt_recipient.as_deref());
    builder = builder.query("is_spoof", args.is_spoof.as_deref());
    builder = builder.query("is_acceptable_sender", args.is_acceptable_sender.as_deref());
    builder = builder.query("verify_sender", args.verify_sender.as_deref());
    builder = builder.query("pattern_type", args.pattern_type.as_deref());
    builder = builder.query("pattern", args.pattern.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: EmailSecurityListAllowPoliciesResponse = serde_json::from_slice(&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}/email-security/settings/allow_policies
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/email-security/settings/allow_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 = email_security_create_allow_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_create_allow_policy_request<F>(
    client: DynNetClient,
    args: &EmailSecurityCreateAllowPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityCreateAllowPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/allow_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: EmailSecurityCreateAllowPolicyResponse = serde_json::from_slice(&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}/email-security/settings/allow_policies/batch
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/email-security/settings/allow_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 = email_security_get_allow_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_allow_policy_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetAllowPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetAllowPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/allow_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: EmailSecurityGetAllowPolicyResponse = serde_json::from_slice(&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}/email-security/settings/allow_policies/{policy_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/email-security/settings/allow_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 = email_security_update_allow_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_update_allow_policy_request<F>(
    client: DynNetClient,
    args: &EmailSecurityUpdateAllowPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityUpdateAllowPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/allow_policies/{}",
        args.account_id,
        args.policy_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: EmailSecurityUpdateAllowPolicyResponse = serde_json::from_slice(&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}/email-security/settings/allow_policies/{policy_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/email-security/settings/allow_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 = email_security_delete_allow_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_delete_allow_policy_request<F>(
    client: DynNetClient,
    args: &EmailSecurityDeleteAllowPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityDeleteAllowPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/allow_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: EmailSecurityDeleteAllowPolicyResponse = serde_json::from_slice(&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}/email-security/settings/block_senders
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("search", args.search.as_deref());
    builder = builder.query("pattern_type", args.pattern_type.as_deref());
    builder = builder.query("pattern", args.pattern.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: EmailSecurityListBlockedSendersResponse = serde_json::from_slice(&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}/email-security/settings/block_senders
// -----------------------------------------------------------------------------

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

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

/// GET /accounts/{account_id}/email-security/settings/block_senders/{pattern_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 = email_security_get_blocked_sender_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_blocked_sender_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetBlockedSenderArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetBlockedSenderResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/block_senders/{}",
        args.account_id,
        args.pattern_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: EmailSecurityGetBlockedSenderResponse = serde_json::from_slice(&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}/email-security/settings/block_senders/{pattern_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/email-security/settings/block_senders/{pattern_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 = email_security_update_blocked_sender_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_update_blocked_sender_request<F>(
    client: DynNetClient,
    args: &EmailSecurityUpdateBlockedSenderArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityUpdateBlockedSenderResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/block_senders/{}",
        args.account_id,
        args.pattern_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: EmailSecurityUpdateBlockedSenderResponse = serde_json::from_slice(&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}/email-security/settings/block_senders/{pattern_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/email-security/settings/block_senders/{pattern_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 = email_security_delete_blocked_sender_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_delete_blocked_sender_request<F>(
    client: DynNetClient,
    args: &EmailSecurityDeleteBlockedSenderArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityDeleteBlockedSenderResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/block_senders/{}",
        args.account_id,
        args.pattern_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: EmailSecurityDeleteBlockedSenderResponse = serde_json::from_slice(&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}/email-security/settings/impersonation_registry
// -----------------------------------------------------------------------------

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

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

    builder = builder.query("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("search", args.search.as_deref());
    builder = builder.query("provenance", args.provenance.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: EmailSecurityListDisplayNamesResponse = serde_json::from_slice(&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}/email-security/settings/impersonation_registry
// -----------------------------------------------------------------------------

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

/// GET /accounts/{account_id}/email-security/settings/impersonation_registry/{display_name_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 = email_security_get_display_name_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_get_display_name_request<F>(
    client: DynNetClient,
    args: &EmailSecurityGetDisplayNameArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityGetDisplayNameResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/impersonation_registry/{}",
        args.account_id,
        args.display_name_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: EmailSecurityGetDisplayNameResponse = serde_json::from_slice(&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}/email-security/settings/impersonation_registry/{display_name_id}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/email-security/settings/impersonation_registry/{display_name_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 = email_security_update_display_name_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_update_display_name_request<F>(
    client: DynNetClient,
    args: &EmailSecurityUpdateDisplayNameArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityUpdateDisplayNameResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/impersonation_registry/{}",
        args.account_id,
        args.display_name_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: EmailSecurityUpdateDisplayNameResponse = serde_json::from_slice(&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}/email-security/settings/impersonation_registry/{display_name_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/email-security/settings/impersonation_registry/{display_name_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 = email_security_delete_display_name_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_delete_display_name_request<F>(
    client: DynNetClient,
    args: &EmailSecurityDeleteDisplayNameArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecurityDeleteDisplayNameResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/settings/impersonation_registry/{}",
        args.account_id,
        args.display_name_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: EmailSecurityDeleteDisplayNameResponse = serde_json::from_slice(&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}/email-security/submissions
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/email-security/submissions.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = email_security_submissions_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_security_submissions_request<F>(
    client: DynNetClient,
    args: &EmailSecuritySubmissionsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailSecuritySubmissionsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email-security/submissions",
        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("start", args.start.as_deref());
    builder = builder.query("end", args.end.as_deref());
    builder = builder.query("type", args.r#type.as_deref());
    builder = builder.query("submission_id", args.submission_id.as_deref());
    builder = builder.query("original_disposition", args.original_disposition.as_deref());
    builder = builder.query("requested_disposition", args.requested_disposition.as_deref());
    builder = builder.query("outcome_disposition", args.outcome_disposition.as_deref());
    builder = builder.query("status", args.status.as_deref());
    builder = builder.query("query", args.query.as_deref());
    builder = builder.query("customer_status", args.customer_status.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: EmailSecuritySubmissionsResponse = serde_json::from_slice(&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}/email/routing/addresses
// -----------------------------------------------------------------------------

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

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

/// GET /accounts/{account_id}/email/routing/addresses/{destination_address_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 = email_routing_destination_addresses_get_a_destination_address_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_routing_destination_addresses_get_a_destination_address_request<F>(
    client: DynNetClient,
    args: &EmailRoutingDestinationAddressesGetADestinationAddressArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailDestinationAddressResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email/routing/addresses/{}",
        args.account_id,
        args.destination_address_identifier,
    );
    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: EmailDestinationAddressResponseSingle = serde_json::from_slice(&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}/email/routing/addresses/{destination_address_identifier}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/email/routing/addresses/{destination_address_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 = email_routing_destination_addresses_delete_destination_address_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn email_routing_destination_addresses_delete_destination_address_request<F>(
    client: DynNetClient,
    args: &EmailRoutingDestinationAddressesDeleteDestinationAddressArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EmailDestinationAddressResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/email/routing/addresses/{}",
        args.account_id,
        args.destination_address_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: EmailDestinationAddressResponseSingle = serde_json::from_slice(&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}/email/sending/send
// -----------------------------------------------------------------------------

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

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

/// GET /radar/email/routing/summary/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_email_routing_summary_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_email_routing_summary_request<F>(
    client: DynNetClient,
    args: &RadarGetEmailRoutingSummaryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEmailRoutingSummaryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/email/routing/summary/{}",
        args.dimension,
    );
    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("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("arc", args.arc.as_deref());
    builder = builder.query("dkim", args.dkim.as_deref());
    builder = builder.query("dmarc", args.dmarc.as_deref());
    builder = builder.query("spf", args.spf.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("encrypted", args.encrypted.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("format", args.format.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: RadarGetEmailRoutingSummaryResponse = serde_json::from_slice(&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 /radar/email/routing/timeseries_groups/{dimension}
// -----------------------------------------------------------------------------

/// GET /radar/email/routing/timeseries_groups/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_email_routing_timeseries_group_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_email_routing_timeseries_group_request<F>(
    client: DynNetClient,
    args: &RadarGetEmailRoutingTimeseriesGroupArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEmailRoutingTimeseriesGroupResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/email/routing/timeseries_groups/{}",
        args.dimension,
    );
    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("aggInterval", args.agg_interval.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("arc", args.arc.as_deref());
    builder = builder.query("dkim", args.dkim.as_deref());
    builder = builder.query("dmarc", args.dmarc.as_deref());
    builder = builder.query("spf", args.spf.as_deref());
    builder = builder.query("ipVersion", args.ip_version.as_deref());
    builder = builder.query("encrypted", args.encrypted.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("format", args.format.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: RadarGetEmailRoutingTimeseriesGroupResponse = serde_json::from_slice(&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 /radar/email/security/summary/{dimension}
// -----------------------------------------------------------------------------

/// GET /radar/email/security/summary/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_email_security_summary_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_email_security_summary_request<F>(
    client: DynNetClient,
    args: &RadarGetEmailSecuritySummaryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEmailSecuritySummaryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/email/security/summary/{}",
        args.dimension,
    );
    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("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("arc", args.arc.as_deref());
    builder = builder.query("dkim", args.dkim.as_deref());
    builder = builder.query("dmarc", args.dmarc.as_deref());
    builder = builder.query("spf", args.spf.as_deref());
    builder = builder.query("tlsVersion", args.tls_version.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("format", args.format.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: RadarGetEmailSecuritySummaryResponse = serde_json::from_slice(&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 /radar/email/security/timeseries_groups/{dimension}
// -----------------------------------------------------------------------------

/// GET /radar/email/security/timeseries_groups/{dimension}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = radar_get_email_security_timeseries_group_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn radar_get_email_security_timeseries_group_request<F>(
    client: DynNetClient,
    args: &RadarGetEmailSecurityTimeseriesGroupArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEmailSecurityTimeseriesGroupResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/radar/email/security/timeseries_groups/{}",
        args.dimension,
    );
    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("aggInterval", args.agg_interval.as_deref());
    builder = builder.query("name", args.name.as_deref());
    builder = builder.query("dateRange", args.date_range.as_deref());
    builder = builder.query("dateStart", args.date_start.as_deref());
    builder = builder.query("dateEnd", args.date_end.as_deref());
    builder = builder.query("arc", args.arc.as_deref());
    builder = builder.query("dkim", args.dkim.as_deref());
    builder = builder.query("dmarc", args.dmarc.as_deref());
    builder = builder.query("spf", args.spf.as_deref());
    builder = builder.query("tlsVersion", args.tls_version.as_deref());
    builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
    builder = builder.query("format", args.format.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: RadarGetEmailSecurityTimeseriesGroupResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}